/*
$Log$
+ Revision 1.17 2000/06/09 14:58:37 jbarbosa
+ New digitisation per particle type
+
Revision 1.16 2000/04/19 12:55:43 morsch
Newly structured and updated version (JB, AM)
#include <TVector.h>
#include <TObjArray.h>
#include <TArrayF.h>
+#include <TFile.h>
+#include <TParticle.h>
+#include <iostream.h>
#include "AliRICH.h"
-#include "AliRICHHitMap.h"
+#include "AliRICHSegmentation.h"
+#include "AliRICHHit.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHPadHit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHTransientDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit.h"
+#include "AliRICHHitMapA1.h"
#include "AliRICHClusterFinder.h"
#include "AliRun.h"
#include "AliMC.h"
#include "AliPoints.h"
-#include "iostream.h"
#include "AliCallf77.h"
-#include "TParticle.h"
+
// Static variables for the pad-hit iterator routines
static Int_t sMaxIterPad=0;
//___________________________________________
AliRICH::AliRICH()
{
+// Default constructor for RICH manager class
+
fIshunt = 0;
fHits = 0;
fPadHits = 0;
fNcerenkovs = 0;
fIshunt = 0;
- fNdch = new Int_t[7];
+ fNdch = new Int_t[kNCH];
- fDchambers = new TObjArray(7);
+ fDchambers = new TObjArray(kNCH);
- fRecHits = new TObjArray(7);
+ fRecHits = new TObjArray(kNCH);
Int_t i;
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
(*fDchambers)[i] = new TClonesArray("AliRICHDigit",10000);
fNdch[i]=0;
}
- fNrawch = new Int_t[7];
+ fNrawch = new Int_t[kNCH];
- fRawClusters = new TObjArray(7);
+ fRawClusters = new TObjArray(kNCH);
//printf("Created fRwClusters with adress:%p",fRawClusters);
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
(*fRawClusters)[i] = new TClonesArray("AliRICHRawCluster",10000);
fNrawch[i]=0;
}
- fNrechits = new Int_t[7];
+ fNrechits = new Int_t[kNCH];
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
(*fRecHits)[i] = new TClonesArray("AliRICHRecHit",1000);
}
//printf("Created fRecHits with adress:%p",fRecHits);
SetMarkerColor(kRed);
}
+AliRICH::AliRICH(const AliRICH& RICH)
+{
+// Copy Constructor
+}
+
+
//___________________________________________
AliRICH::~AliRICH()
{
+
+// Destructor of RICH manager class
+
fIshunt = 0;
delete fHits;
delete fPadHits;
//___________________________________________
void AliRICH::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{
+
+//
+// Adds a hit to the Hits list
+//
+
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliRICHHit(fIshunt,track,vol,hits);
}
//_____________________________________________________________________________
void AliRICH::AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs)
{
+
+//
+// Adds a RICH cerenkov hit to the Cerenkov Hits list
+//
+
TClonesArray &lcerenkovs = *fCerenkovs;
new(lcerenkovs[fNcerenkovs++]) AliRICHCerenkov(fIshunt,track,vol,cerenkovs);
//printf ("Done for Cerenkov %d\n\n\n\n",fNcerenkovs);
//___________________________________________
void AliRICH::AddPadHit(Int_t *clhits)
{
+
+//
+// Add a RICH pad hit to the list
+//
+
TClonesArray &lPadHits = *fPadHits;
new(lPadHits[fNPadHits++]) AliRICHPadHit(clhits);
}
//_____________________________________________________________________________
void AliRICH::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
{
- //
- // Add a RICH digit to the list
- //
+
+ //
+ // Add a RICH digit to the list
+ //
TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
new(ldigits[fNdch[id]++]) AliRICHDigit(tracks,charges,digits);
//_____________________________________________________________________________
void AliRICH::AddRecHit(Int_t id, Float_t *rechit)
{
- //
- // Add a RICH reconstructed hit to the list
- //
+
+ //
+ // Add a RICH reconstructed hit to the list
+ //
TClonesArray &lrec = *((TClonesArray*)(*fRecHits)[id]);
new(lrec[fNrechits[id]++]) AliRICHRecHit(id,rechit);
void AliRICH::BuildGeometry()
{
- //
- // Builds a TNode geometry for event display
- //
- TNode *Node, *Top;
+
+ //
+ // Builds a TNode geometry for event display
+ //
+ TNode *node, *top;
const int kColorRICH = kGreen;
//
- Top=gAlice->GetGeometry()->GetNode("alice");
+ top=gAlice->GetGeometry()->GetNode("alice");
new TBRIK("S_RICH","S_RICH","void",71.09999,11.5,73.15);
- Top->cd();
+ top->cd();
Float_t pos1[3]={0,471.8999,165.2599};
//Chamber(0).SetChamberTransform(pos1[0],pos1[1],pos1[2],
new TRotMatrix("rot993","rot993",90,0,70.69,90,19.30999,-90);
- Node = new TNode("RICH1","RICH1","S_RICH",pos1[0],pos1[1],pos1[2],"rot993");
+ node = new TNode("RICH1","RICH1","S_RICH",pos1[0],pos1[1],pos1[2],"rot993");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos2[3]={171,470,0};
//Chamber(1).SetChamberTransform(pos2[0],pos2[1],pos2[2],
new TRotMatrix("rot994","rot994",90,-20,90,70,0,0);
- Node = new TNode("RICH2","RICH2","S_RICH",pos2[0],pos2[1],pos2[2],"rot994");
+ node = new TNode("RICH2","RICH2","S_RICH",pos2[0],pos2[1],pos2[2],"rot994");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos3[3]={0,500,0};
//Chamber(2).SetChamberTransform(pos3[0],pos3[1],pos3[2],
new TRotMatrix("rot995","rot995",90,0,90,90,0,0);
- Node = new TNode("RICH3","RICH3","S_RICH",pos3[0],pos3[1],pos3[2],"rot995");
+ node = new TNode("RICH3","RICH3","S_RICH",pos3[0],pos3[1],pos3[2],"rot995");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos4[3]={-171,470,0};
//Chamber(3).SetChamberTransform(pos4[0],pos4[1],pos4[2],
new TRotMatrix("rot996","rot996",90,20,90,110,0,0);
- Node = new TNode("RICH4","RICH4","S_RICH",pos4[0],pos4[1],pos4[2],"rot996");
+ node = new TNode("RICH4","RICH4","S_RICH",pos4[0],pos4[1],pos4[2],"rot996");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos5[3]={161.3999,443.3999,-165.3};
//Chamber(4).SetChamberTransform(pos5[0],pos5[1],pos5[2],
new TRotMatrix("rot997","rot997",90,340,108.1999,70,18.2,70);
- Node = new TNode("RICH5","RICH5","S_RICH",pos5[0],pos5[1],pos5[2],"rot997");
+ node = new TNode("RICH5","RICH5","S_RICH",pos5[0],pos5[1],pos5[2],"rot997");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos6[3]={0., 471.9, -165.3,};
//Chamber(5).SetChamberTransform(pos6[0],pos6[1],pos6[2],
new TRotMatrix("rot998","rot998",90,0,109.3099,90,19.30999,90);
- Node = new TNode("RICH6","RICH6","S_RICH",pos6[0],pos6[1],pos6[2],"rot998");
+ node = new TNode("RICH6","RICH6","S_RICH",pos6[0],pos6[1],pos6[2],"rot998");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
- Top->cd();
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
+ top->cd();
Float_t pos7[3]={-161.399,443.3999,-165.3};
//Chamber(6).SetChamberTransform(pos7[0],pos7[1],pos7[2],
new TRotMatrix("rot999","rot999",90,20,108.1999,110,18.2,110);
- Node = new TNode("RICH7","RICH7","S_RICH",pos7[0],pos7[1],pos7[2],"rot999");
- Node->SetLineColor(kColorRICH);
- fNodes->Add(Node);
+ node = new TNode("RICH7","RICH7","S_RICH",pos7[0],pos7[1],pos7[2],"rot999");
+ node->SetLineColor(kColorRICH);
+ fNodes->Add(node);
}
//___________________________________________
Int_t AliRICH::DistancetoPrimitive(Int_t , Int_t )
{
+
+// Default value
+
return 9999;
}
//___________________________________________
void AliRICH::MakeBranch(Option_t* option)
{
- // Create Tree branches for the RICH.
+ // Create Tree branches for the RICH.
- const Int_t buffersize = 4000;
+ const Int_t kBufferSize = 4000;
char branchname[20];
AliDetector::MakeBranch(option);
sprintf(branchname,"%sCerenkov",GetName());
if (fCerenkovs && gAlice->TreeH()) {
- gAlice->TreeH()->Branch(branchname,&fCerenkovs, buffersize);
+ gAlice->TreeH()->Branch(branchname,&fCerenkovs, kBufferSize);
printf("Making Branch %s for Cerenkov Hits\n",branchname);
}
sprintf(branchname,"%sPadHits",GetName());
if (fPadHits && gAlice->TreeH()) {
- gAlice->TreeH()->Branch(branchname,&fPadHits, buffersize);
+ gAlice->TreeH()->Branch(branchname,&fPadHits, kBufferSize);
printf("Making Branch %s for PadHits\n",branchname);
}
// one branch for digits per chamber
Int_t i;
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
if (fDchambers && gAlice->TreeD()) {
- gAlice->TreeD()->Branch(branchname,&((*fDchambers)[i]), buffersize);
+ gAlice->TreeD()->Branch(branchname,&((*fDchambers)[i]), kBufferSize);
printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
}
}
// one branch for raw clusters per chamber
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
if (fRawClusters && gAlice->TreeR()) {
- gAlice->TreeR()->Branch(branchname,&((*fRawClusters)[i]), buffersize);
+ gAlice->TreeR()->Branch(branchname,&((*fRawClusters)[i]), kBufferSize);
printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
}
}
// one branch for rec hits per chamber
- for (i=0; i<7 ;i++) {
+ for (i=0; i<kNCH ;i++) {
sprintf(branchname,"%sRecHits%d",GetName(),i+1);
if (fRecHits && gAlice->TreeR()) {
- gAlice->TreeR()->Branch(branchname,&((*fRecHits)[i]), buffersize);
+ gAlice->TreeR()->Branch(branchname,&((*fRecHits)[i]), kBufferSize);
printf("Making Branch %s for rec. hits in chamber %d\n",branchname,i+1);
}
}
//___________________________________________
void AliRICH::SetTreeAddress()
{
- // Set branch address for the Hits and Digits Tree.
+ // Set branch address for the Hits and Digits Tree.
char branchname[20];
Int_t i;
}
if (treeD) {
- for (int i=0; i<7; i++) {
+ for (int i=0; i<kNCH; i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
if (fDchambers) {
branch = treeD->GetBranch(branchname);
}
}
if (treeR) {
- for (i=0; i<7; i++) {
+ for (i=0; i<kNCH; i++) {
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
if (fRawClusters) {
branch = treeR->GetBranch(branchname);
}
}
- for (i=0; i<7; i++) {
+ for (i=0; i<kNCH; i++) {
sprintf(branchname,"%sRecHits%d",GetName(),i+1);
if (fRecHits) {
branch = treeR->GetBranch(branchname);
//___________________________________________
void AliRICH::ResetHits()
{
- // Reset number of clusters and the cluster array for this detector
+ // Reset number of clusters and the cluster array for this detector
AliDetector::ResetHits();
fNPadHits = 0;
fNcerenkovs = 0;
//____________________________________________
void AliRICH::ResetDigits()
{
- //
- // Reset number of digits and the digits array for this detector
- //
- for ( int i=0;i<7;i++ ) {
+ //
+ // Reset number of digits and the digits array for this detector
+ //
+ for ( int i=0;i<kNCH;i++ ) {
if ((*fDchambers)[i]) (*fDchambers)[i]->Clear();
if (fNdch) fNdch[i]=0;
}
//____________________________________________
void AliRICH::ResetRawClusters()
{
- //
- // Reset number of raw clusters and the raw clust array for this detector
- //
- for ( int i=0;i<7;i++ ) {
+ //
+ // Reset number of raw clusters and the raw clust array for this detector
+ //
+ for ( int i=0;i<kNCH;i++ ) {
if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
if (fNrawch) fNrawch[i]=0;
}
//____________________________________________
void AliRICH::ResetRecHits()
{
- //
- // Reset number of raw clusters and the raw clust array for this detector
- //
+ //
+ // Reset number of raw clusters and the raw clust array for this detector
+ //
- for ( int i=0;i<7;i++ ) {
+ for ( int i=0;i<kNCH;i++ ) {
if ((*fRecHits)[i]) ((TClonesArray*)(*fRecHits)[i])->Clear();
if (fNrechits) fNrechits[i]=0;
}
//___________________________________________
void AliRICH::SetGeometryModel(Int_t id, AliRICHGeometry *geometry)
{
+
+//
+// Setter for the RICH geometry model
+//
+
+
((AliRICHChamber*) (*fChambers)[id])->GeometryModel(geometry);
}
//___________________________________________
void AliRICH::SetSegmentationModel(Int_t id, AliRICHSegmentation *segmentation)
{
+
+//
+// Setter for the RICH segmentation model
+//
+
((AliRICHChamber*) (*fChambers)[id])->SegmentationModel(segmentation);
}
//___________________________________________
void AliRICH::SetResponseModel(Int_t id, AliRICHResponse *response)
{
+
+//
+// Setter for the RICH response model
+//
+
((AliRICHChamber*) (*fChambers)[id])->ResponseModel(response);
}
void AliRICH::SetReconstructionModel(Int_t id, AliRICHClusterFinder *reconst)
{
+
+//
+// Setter for the RICH reconstruction model (clusters)
+//
+
((AliRICHChamber*) (*fChambers)[id])->ReconstructionModel(reconst);
}
void AliRICH::SetNsec(Int_t id, Int_t nsec)
{
+
+//
+// Sets the number of padplanes
+//
+
((AliRICHChamber*) (*fChambers)[id])->SetNsec(nsec);
}
void AliRICH::StepManager()
{
+
+// Dummy step manager (should never be called)
+
}
-void AliRICH::FindClusters(Int_t nev,Int_t last_entry)
+void AliRICH::FindClusters(Int_t nev,Int_t lastEntry)
{
//
for (Int_t icat=1;icat<2;icat++) {
gAlice->ResetDigits();
gAlice->TreeD()->GetEvent(1); // spurious +1 ...
- for (Int_t ich=0;ich<7;ich++) {
+ for (Int_t ich=0;ich<kNCH;ich++) {
AliRICHChamber* iChamber=(AliRICHChamber*) (*fChambers)[ich];
- TClonesArray *RICHdigits = this->DigitsAddress(ich);
- if (RICHdigits == 0)
+ TClonesArray *pRICHdigits = this->DigitsAddress(ich);
+ if (pRICHdigits == 0)
continue;
//
// Get ready the current chamber stuff
if (seg) {
rec->SetSegmentation(seg);
rec->SetResponse(response);
- rec->SetDigits(RICHdigits);
+ rec->SetDigits(pRICHdigits);
rec->SetChamber(ich);
if (nev==0) rec->CalibrateCOG();
rec->FindRawClusters();
gAlice->TreeR()->Fill();
TClonesArray *fRch;
- for (int i=0;i<7;i++) {
+ for (int i=0;i<kNCH;i++) {
fRch=RawClustAddress(i);
int nraw=fRch->GetEntriesFast();
printf ("Chamber %d, raw clusters %d\n",i,nraw);
//
R__b >> fChambers;
// Stream chamber related information
- for (Int_t i =0; i<7; i++) {
+ for (Int_t i =0; i<kNCH; i++) {
iChamber=(AliRICHChamber*) (*fChambers)[i];
iChamber->Streamer(R__b);
segmentation=iChamber->GetSegmentationModel();
R__b << fDchambers;
R__b << fRawClusters;
R__b << fRecHits; //diff
- R__b.WriteArray(fNdch, 7);
- R__b.WriteArray(fNrawch, 7);
- R__b.WriteArray(fNrechits, 7);
+ R__b.WriteArray(fNdch, kNCH);
+ R__b.WriteArray(fNrawch, kNCH);
+ R__b.WriteArray(fNrechits, kNCH);
//
R__b << fChambers;
// Stream chamber related information
- for (Int_t i =0; i<7; i++) {
+ for (Int_t i =0; i<kNCH; i++) {
iChamber=(AliRICHChamber*) (*fChambers)[i];
iChamber->Streamer(R__b);
segmentation=iChamber->GetSegmentationModel();
AliRICHPadHit* AliRICH::NextPad(TClonesArray *clusters)
{
+
+ // Iterates over pads
+
sCurIterPad++;
if (sCurIterPad <= sMaxIterPad) {
return (AliRICHPadHit*) clusters->UncheckedAt(sCurIterPad-1);
// background when add! otherwise the track info for signal will be lost !
static Bool_t first=kTRUE;
- static TFile *File;
- char *Add = strstr(option,"Add");
+ static TFile *pFile;
+ char *addBackground = strstr(option,"Add");
FILE* points; //these will be the digits...
Int_t trk[50];
Int_t chtrk[50];
TObjArray *list=new TObjArray;
- static TClonesArray *p_adr=0;
- if(!p_adr) p_adr=new TClonesArray("TVector",1000);
+ static TClonesArray *pAddress=0;
+ if(!pAddress) pAddress=new TClonesArray("TVector",1000);
Int_t digits[5];
- AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
- AliRICHHitMap* HitMap[10];
+ AliRICH *pRICH = (AliRICH *) gAlice->GetDetector("RICH");
+ AliRICHHitMap* pHitMap[10];
Int_t i;
- for (i=0; i<10; i++) {HitMap[i]=0;}
- if (Add ) {
+ for (i=0; i<10; i++) {pHitMap[i]=0;}
+ if (addBackground ) {
if(first) {
fFileName=filename;
cout<<"filename"<<fFileName<<endl;
- File=new TFile(fFileName);
+ pFile=new TFile(fFileName);
cout<<"I have opened "<<fFileName<<" file "<<endl;
fHits2 = new TClonesArray("AliRICHHit",1000 );
fClusters2 = new TClonesArray("AliRICHPadHit",10000);
first=kFALSE;
}
- File->cd();
+ pFile->cd();
// Get Hits Tree header from file
if(fHits2) fHits2->Clear();
if(fClusters2) fClusters2->Clear();
Int_t countadr=0;
for (int icat=0; icat<1; icat++) {
Int_t counter=0;
- for (i =0; i<7; i++) {
+ for (i =0; i<kNCH; i++) {
iChamber=(AliRICHChamber*) (*fChambers)[i];
if (iChamber->Nsec()==1 && icat==1) {
continue;
} else {
segmentation=iChamber->GetSegmentationModel(icat+1);
}
- HitMap[i] = new AliRICHHitMapA1(segmentation, list);
+ pHitMap[i] = new AliRICHHitMapA1(segmentation, list);
}
//
// Loop over tracks
//
- TTree *TH = gAlice->TreeH();
- Int_t ntracks =(Int_t) TH->GetEntries();
+ TTree *treeH = gAlice->TreeH();
+ Int_t ntracks =(Int_t) treeH->GetEntries();
for (Int_t track=0; track<ntracks; track++) {
gAlice->ResetHits();
- TH->GetEvent(track);
+ treeH->GetEvent(track);
//
// Loop over hits
- for(AliRICHHit* mHit=(AliRICHHit*)RICH->FirstHit(-1);
+ for(AliRICHHit* mHit=(AliRICHHit*)pRICH->FirstHit(-1);
mHit;
- mHit=(AliRICHHit*)RICH->NextHit())
+ mHit=(AliRICHHit*)pRICH->NextHit())
{
digitse=0;
Int_t nch = mHit->fChamber-1; // chamber number
- if (nch >7) continue;
- iChamber = &(RICH->Chamber(nch));
+ if (nch >kNCH) continue;
+ iChamber = &(pRICH->Chamber(nch));
TParticle *current = (TParticle*)(*gAlice->Particles())[track];
//
// Loop over pad hits
for (AliRICHPadHit* mPad=
- (AliRICHPadHit*)RICH->FirstPad(mHit,fPadHits);
+ (AliRICHPadHit*)pRICH->FirstPad(mHit,fPadHits);
mPad;
- mPad=(AliRICHPadHit*)RICH->NextPad(fPadHits))
+ mPad=(AliRICHPadHit*)pRICH->NextPad(fPadHits))
{
Int_t cathode = mPad->fCathode; // cathode number
Int_t ipx = mPad->fPadX; // pad number on X
Float_t thex, they;
segmentation=iChamber->GetSegmentationModel(cathode);
segmentation->GetPadCxy(ipx,ipy,thex,they);
- new((*p_adr)[countadr++]) TVector(2);
- TVector &trinfo=*((TVector*) (*p_adr)[countadr-1]);
+ new((*pAddress)[countadr++]) TVector(2);
+ TVector &trinfo=*((TVector*) (*pAddress)[countadr-1]);
trinfo(0)=(Float_t)track;
trinfo(1)=(Float_t)iqpad;
AliRICHTransientDigit* pdigit;
// build the list of fired pads and update the info
- if (!HitMap[nch]->TestHit(ipx, ipy)) {
+ if (!pHitMap[nch]->TestHit(ipx, ipy)) {
list->AddAtAndExpand(new AliRICHTransientDigit(nch,digits),counter);
- HitMap[nch]->SetHit(ipx, ipy, counter);
+ pHitMap[nch]->SetHit(ipx, ipy, counter);
counter++;
pdigit=(AliRICHTransientDigit*)list->At(list->GetLast());
// list of tracks
TObjArray *trlist=(TObjArray*)pdigit->TrackList();
trlist->Add(&trinfo);
} else {
- pdigit=(AliRICHTransientDigit*) HitMap[nch]->GetHit(ipx, ipy);
+ pdigit=(AliRICHTransientDigit*) pHitMap[nch]->GetHit(ipx, ipy);
// update charge
(*pdigit).fSignal+=iqpad;
// update list of tracks
TObjArray* trlist=(TObjArray*)pdigit->TrackList();
- Int_t last_entry=trlist->GetLast();
- TVector *ptrk_p=(TVector*)trlist->At(last_entry);
- TVector &ptrk=*ptrk_p;
- Int_t last_track=Int_t(ptrk(0));
- Int_t last_charge=Int_t(ptrk(1));
- if (last_track==track) {
- last_charge+=iqpad;
- trlist->RemoveAt(last_entry);
- trinfo(0)=last_track;
- trinfo(1)=last_charge;
- trlist->AddAt(&trinfo,last_entry);
+ Int_t lastEntry=trlist->GetLast();
+ TVector *ptrkP=(TVector*)trlist->At(lastEntry);
+ TVector &ptrk=*ptrkP;
+ Int_t lastTrack=Int_t(ptrk(0));
+ Int_t lastCharge=Int_t(ptrk(1));
+ if (lastTrack==track) {
+ lastCharge+=iqpad;
+ trlist->RemoveAt(lastEntry);
+ trinfo(0)=lastTrack;
+ trinfo(1)=lastCharge;
+ trlist->AddAt(&trinfo,lastEntry);
} else {
trlist->Add(&trinfo);
}
printf("Attention - tracks: %d (>2)\n",nptracks);
//printf("cat,nch,ix,iy %d %d %d %d \n",icat+1,nch,ipx,ipy);
for (Int_t tr=0;tr<nptracks;tr++) {
- TVector *pptrk_p=(TVector*)trlist->At(tr);
- TVector &pptrk=*pptrk_p;
+ TVector *pptrkP=(TVector*)trlist->At(tr);
+ TVector &pptrk=*pptrkP;
trk[tr]=Int_t(pptrk(0));
chtrk[tr]=Int_t(pptrk(1));
}
// open the file with background
- if (Add ) {
+ if (addBackground ) {
ntracks =(Int_t)TrH1->GetEntries();
//printf("background - icat,ntracks1 %d %d\n",icat,ntracks);
//printf("background - Start loop over tracks \n");
mHit=(AliRICHHit*) (*fHits2)[j];
Int_t nch = mHit->fChamber-1; // chamber number
if (nch >6) continue;
- iChamber = &(RICH->Chamber(nch));
+ iChamber = &(pRICH->Chamber(nch));
Int_t rmin = (Int_t)iChamber->RInner();
Int_t rmax = (Int_t)iChamber->ROuter();
//
// Loop over pad hits
for (AliRICHPadHit* mPad=
- (AliRICHPadHit*)RICH->FirstPad(mHit,fClusters2);
+ (AliRICHPadHit*)pRICH->FirstPad(mHit,fClusters2);
mPad;
- mPad=(AliRICHPadHit*)RICH->NextPad(fClusters2))
+ mPad=(AliRICHPadHit*)pRICH->NextPad(fClusters2))
{
Int_t cathode = mPad->fCathode; // cathode number
Int_t ipx = mPad->fPadX; // pad number on X
segmentation->GetPadCxy(ipx,ipy,thex,they);
Float_t rpad=TMath::Sqrt(thex*thex+they*they);
if (rpad < rmin || iqpad ==0 || rpad > rmax) continue;
- new((*p_adr)[countadr++]) TVector(2);
- TVector &trinfo=*((TVector*) (*p_adr)[countadr-1]);
+ new((*pAddress)[countadr++]) TVector(2);
+ TVector &trinfo=*((TVector*) (*pAddress)[countadr-1]);
trinfo(0)=-1; // tag background
trinfo(1)=-1;
digits[0]=ipx;
digits[1]=ipy;
digits[2]=iqpad;
if (trak <4 && icat==0 && nch==0)
- printf("bgr - HitMap[nch]->TestHit(ipx, ipy),trak %d %d\n",
- HitMap[nch]->TestHit(ipx, ipy),trak);
+ printf("bgr - pHitMap[nch]->TestHit(ipx, ipy),trak %d %d\n",
+ pHitMap[nch]->TestHit(ipx, ipy),trak);
AliRICHTransientDigit* pdigit;
// build the list of fired pads and update the info
- if (!HitMap[nch]->TestHit(ipx, ipy)) {
+ if (!pHitMap[nch]->TestHit(ipx, ipy)) {
list->AddAtAndExpand(new AliRICHTransientDigit(nch,digits),counter);
- HitMap[nch]->SetHit(ipx, ipy, counter);
+ pHitMap[nch]->SetHit(ipx, ipy, counter);
counter++;
printf("bgr new elem in list - counter %d\n",counter);
TObjArray *trlist=(TObjArray*)pdigit->TrackList();
trlist->Add(&trinfo);
} else {
- pdigit=(AliRICHTransientDigit*) HitMap[nch]->GetHit(ipx, ipy);
+ pdigit=(AliRICHTransientDigit*) pHitMap[nch]->GetHit(ipx, ipy);
// update charge
(*pdigit).fSignal+=iqpad;
// update list of tracks
TObjArray* trlist=(TObjArray*)pdigit->TrackList();
- Int_t last_entry=trlist->GetLast();
- TVector *ptrk_p=(TVector*)trlist->At(last_entry);
- TVector &ptrk=*ptrk_p;
- Int_t last_track=Int_t(ptrk(0));
- if (last_track==-1) {
+ Int_t lastEntry=trlist->GetLast();
+ TVector *ptrkP=(TVector*)trlist->At(lastEntry);
+ TVector &ptrk=*ptrkP;
+ Int_t lastTrack=Int_t(ptrk(0));
+ if (lastTrack==-1) {
continue;
} else {
trlist->Add(&trinfo);
Int_t nptracks=trlist->GetEntriesFast();
if (nptracks > 0) {
for (Int_t tr=0;tr<nptracks;tr++) {
- TVector *pptrk_p=(TVector*)trlist->At(tr);
- TVector &pptrk=*pptrk_p;
+ TVector *pptrkP=(TVector*)trlist->At(tr);
+ TVector &pptrk=*pptrkP;
trk[tr]=Int_t(pptrk(0));
chtrk[tr]=Int_t(pptrk(1));
}
} // hit loop
} // track loop
TTree *fAli=gAlice->TreeK();
- if (fAli) File =fAli->GetCurrentFile();
- File->cd();
+ if (fAli) pFile =fAli->GetCurrentFile();
+ pFile->cd();
} // if Add
Int_t tracks[10];
AliRICHResponse * response=iChamber->GetResponseModel();
Int_t adcmax= (Int_t) response->MaxAdc();
// add white noise and do zero-suppression and signal truncation (new electronics,old electronics gaus 1.2,0.2)
- Float_t MeanNoise = gRandom->Gaus(1.7, 0.25);
- Float_t Noise = gRandom->Gaus(0, MeanNoise);
- q+=(Int_t)Noise;
+ Float_t meanNoise = gRandom->Gaus(1.7, 0.25);
+ Float_t noise = gRandom->Gaus(0, meanNoise);
+ q+=(Int_t)noise;
// magic number to be parametrised !!!
if ( q <= 6.8) continue;
if ( q >= adcmax) q=adcmax;
//icat,ich,digits[0],digits[1],q);
}
for (Int_t tr=0;tr<nptracks;tr++) {
- TVector *pp_p=(TVector*)trlist->At(tr);
- TVector &pp =*pp_p;
+ TVector *ppP=(TVector*)trlist->At(tr);
+ TVector &pp =*ppP;
tracks[tr]=Int_t(pp(0));
charges[tr]=Int_t(pp(1));
} //end loop over list of tracks for one pad
fprintf(points,"%4d, %4d, %4d\n",digits[0],digits[1],digits[2]);
// fill digits
- RICH->AddDigits(ich,tracks,charges,digits);
+ pRICH->AddDigits(ich,tracks,charges,digits);
}
gAlice->TreeD()->Fill();
list->Delete();
- for(Int_t ii=0;ii<7;++ii) {
- if (HitMap[ii]) {
- hm=HitMap[ii];
+ for(Int_t ii=0;ii<kNCH;++ii) {
+ if (pHitMap[ii]) {
+ hm=pHitMap[ii];
delete hm;
- HitMap[ii]=0;
+ pHitMap[ii]=0;
}
}
//Stat_t ndig=TD->GetEntries();
//cout<<"number of digits "<<ndig<<endl;
TClonesArray *fDch;
- for (int k=0;k<7;k++) {
- fDch= RICH->DigitsAddress(k);
+ for (int k=0;k<kNCH;k++) {
+ fDch= pRICH->DigitsAddress(k);
int ndigit=fDch->GetEntriesFast();
printf ("Chamber %d digits %d \n",k,ndigit);
}
- RICH->ResetDigits();
+ pRICH->ResetDigits();
} //end loop over cathodes
char hname[30];
sprintf(hname,"TreeD%d",nev);
// reset tree
// gAlice->TreeD()->Reset();
delete list;
- p_adr->Clear();
+ pAddress->Clear();
// gObjectTable->Print();
}
+AliRICH& AliRICH::operator=(const AliRICH& rhs)
+{
+// Assignment operator
+ return *this;
+
+}
+Int_t AliRICH::MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss, Int_t idvol, ResponseType res)
+{
+//
+// Calls the charge disintegration method of the current chamber and adds
+// the simulated cluster to the root treee
+//
+ Int_t clhits[kNCH];
+ Float_t newclust[6][500];
+ Int_t nnew;
+
+//
+// Integrated pulse height on chamber
+
+ clhits[0]=fNhits+1;
+
+ ((AliRICHChamber*) (*fChambers)[idvol])->DisIntegration(eloss, xhit, yhit, nnew, newclust, res);
+ Int_t ic=0;
+
+//
+// Add new clusters
+ for (Int_t i=0; i<nnew; i++) {
+ if (Int_t(newclust[3][i]) > 0) {
+ ic++;
+// Cathode plane
+ clhits[1] = Int_t(newclust[5][i]);
+// Cluster Charge
+ clhits[2] = Int_t(newclust[0][i]);
+// Pad: ix
+ clhits[3] = Int_t(newclust[1][i]);
+// Pad: iy
+ clhits[4] = Int_t(newclust[2][i]);
+// Pad: charge
+ clhits[5] = Int_t(newclust[3][i]);
+// Pad: chamber sector
+ clhits[6] = Int_t(newclust[4][i]);
+
+ AddPadHit(clhits);
+ }
+ }
+return nnew;
+}
-#ifndef RICH_H
-#define RICH_H
+#ifndef ALIRICH_H
+#define ALIRICH_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
////////////////////////////////////////////////
#include "AliDetector.h"
#include "AliRICHConst.h"
-#include "AliRICHSegRes.h"
-#include "DataStructures.h"
#include "AliRICHChamber.h"
-#include "AliRICHSegRes.h"
-#include <TVector.h>
-#include <TArrayF.h>
-#include <TObjArray.h>
-#include <TFile.h>
-#include <TTree.h>
-#include <TParticle.h>
-
-static const int NCH=7;
-
+static const int kNCH=7;
+class AliRICHHit;
class AliRICHPadHit;
class AliRICHRawCluster;
class AliRICHRecHit;
class AliRICHSegmentation;
class AliRICHResponse;
class AliRICHEllipse;
+class AliRICHGeometry;
class AliRICH : public AliDetector {
public:
AliRICH();
AliRICH(const char *name, const char *title);
+ AliRICH(const AliRICH& RICH);
virtual ~AliRICH();
- virtual void AddHit(Int_t, Int_t*, Float_t*);
- virtual void AddCerenkov(Int_t, Int_t*, Float_t*);
- virtual void AddPadHit(Int_t*);
- virtual void AddDigits(Int_t, Int_t*, Int_t*, Int_t*);
- virtual void AddRawCluster(Int_t, const AliRICHRawCluster&);
- virtual void AddRecHit(Int_t, Float_t*);
+ virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
+ virtual void AddCerenkov(Int_t track, Int_t *vol, Float_t *cerenkovs);
+ virtual void AddPadHit(Int_t *clhits);
+ virtual void AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits);
+ virtual void AddRawCluster(Int_t id, const AliRICHRawCluster& cluster);
+ virtual void AddRecHit(Int_t id, Float_t* rechit);
virtual void BuildGeometry();
virtual void ResetDigits();
virtual void ResetRawClusters();
virtual void ResetRecHits();
- virtual void FindClusters(Int_t,Int_t);
+ virtual void FindClusters(Int_t nev,Int_t lastEntry);
virtual void Digitise(Int_t nev,Int_t flag,Option_t *opt=" ",Text_t *name=" ");
//
// Configuration Methods (per station id)
// Set Reconstruction Model
virtual void SetReconstructionModel(Int_t id, AliRICHClusterFinder *reconstruction);
// Response Simulation
- virtual Int_t MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss,Int_t id,Response_t res);
+ virtual Int_t MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss,Int_t id, ResponseType res);
// Return reference to Chamber #id
virtual AliRICHChamber& Chamber(Int_t id) {return *((AliRICHChamber *) (*fChambers)[id]);}
// Retrieve pad hits for a given Hit
- virtual AliRICHPadHit* FirstPad(AliRICHHit *, TClonesArray *);
- virtual AliRICHPadHit* NextPad(TClonesArray *);
+ virtual AliRICHPadHit* FirstPad(AliRICHHit *hit, TClonesArray *clusters);
+ virtual AliRICHPadHit* NextPad(TClonesArray *clusters);
// Return pointers to digits
TObjArray *Dchambers() {return fDchambers;}
Int_t *Ndch() {return fNdch;}
virtual TClonesArray *RecHitsAddress(Int_t id) {return ((TClonesArray *) (*fRecHits)[id]);}
// Return pointers to reconstructed clusters
virtual TClonesArray *RawClustAddress(Int_t id) {return ((TClonesArray *) (*fRawClusters)[id]);}
+// Assignment operator
+ AliRICH& operator=(const AliRICH& rhs);
protected:
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+#include "AliRICHCerenkov.h"
+
+ClassImp(AliRICHCerenkov)
+//___________________________________________
+AliRICHCerenkov::AliRICHCerenkov(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
+ AliHit(shunt, track)
+{
+// Constructor for object AliRICHCerenkov
+ fChamber=vol[0];
+ fX=hits[1];
+ fY=hits[2];
+ fZ=hits[3];
+ fTheta=hits[4];
+ fPhi=hits[5];
+ fEloss=hits[7];
+ fPHfirst=(Int_t) hits[8];
+ fPHlast=(Int_t) hits[9];
+ fCMother=Int_t(hits[10]);
+ fIndex = hits[11];
+ fProduction = hits[12];
+ fLoss=hits[13];
+ fMomX=hits[14];
+ fMomY=hits[15];
+ fMomZ=hits[16];
+ fNPads=hits[17];
+ fCerenkovAngle=hits[18];
+}
+
--- /dev/null
+#ifndef ALIRICHCERENKOV_H
+#define ALIRICHCERENKOV_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+
+#include "AliHit.h"
+//------------------------------------------------
+// Cerenkov photon object
+//------------------------------------------------
+
+class AliRICHCerenkov: public AliHit {
+ public:
+ Int_t fChamber; // Chamber number
+ Float_t fTheta ; // Incident theta angle in degrees
+ Float_t fPhi ; // Incident phi angle in degrees
+ Float_t fTlength; // Track length inside the chamber
+ Float_t fEloss; // ionisation energy loss in gas
+ Int_t fPHfirst; // first padhit
+ Int_t fPHlast; // last padhit
+ Int_t fCMother; // index of mother particle
+ Float_t fLoss; // nature of particle loss
+ Float_t fIndex; // Index of photon
+ Float_t fProduction; // Point of production
+ Float_t fMomX; // Local Momentum
+ Float_t fMomY; // Local Momentum
+ Float_t fMomZ; // Local Momentum
+ Float_t fNPads; // Pads hit
+ Float_t fCerenkovAngle; // Cerenkov Angle
+ public:
+ AliRICHCerenkov() {}
+ AliRICHCerenkov(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *Cerenkovs);
+ virtual ~AliRICHCerenkov() {}
+
+ ClassDef(AliRICHCerenkov,1) //Cerenkovs object for set:RICH
+};
+#endif
/*
$Log$
+ Revision 1.2 2000/05/18 13:45:57 jbarbosa
+ Fixed feedback photon origin coordinates
+
Revision 1.1 2000/04/19 12:57:20 morsch
Newly structured and updated version (JB, AM)
#include "AliRICHChamber.h"
-#include "AliRun.h"
+
#include <TLorentzVector.h>
#include <TParticle.h>
#include <TRandom.h>
AliRICHChamber::AliRICHChamber()
{
+
+//
+// Chamber object constructor
+
fSegmentation = 0;
fResponse= 0;
fGeometry= 0;
fnsec=1;
}
-//
-// Get reference to response model
+AliRICHChamber::AliRICHChamber(const AliRICHChamber& Chamber)
+{
+// Copy Constructor
+}
+
+
AliRICHResponse* AliRICHChamber::GetResponseModel()
{
+//
+// Get reference to response model
return fResponse;
}
-// Configure response model
void AliRICHChamber::ResponseModel(AliRICHResponse* thisResponse)
{
+// Configure response model
fResponse=thisResponse;
}
void AliRICHChamber::Init()
{
+// Initialise chambers
fSegmentation->Init(this);
}
void AliRICHChamber::LocaltoGlobal(Float_t pos[3],Float_t Globalpos[3])
{
+// Local coordinates to global coordinates transformation
+
Double_t *fMatrix;
fMatrix = fChamberMatrix->GetMatrix();
Globalpos[0]=pos[0]*fMatrix[0]+pos[1]*fMatrix[3]+pos[2]*fMatrix[6];
void AliRICHChamber::GlobaltoLocal(Float_t pos[3],Float_t Localpos[3])
{
+// Global coordinates to local coordinates transformation
+
Double_t *fMatrixOrig;
TMatrix fMatrixCopy(3,3);
fMatrixOrig = fChamberMatrix->GetMatrix();
void AliRICHChamber::DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit,
- Int_t& nnew,Float_t newclust[6][500],Response_t res)
+ Int_t& nnew,Float_t newclust[6][500],ResponseType res)
{
//
// Generates pad hits (simulated cluster)
LocaltoGlobal(local,global);
- Int_t Nfp=0;
+ Int_t nFp=0;
- if (res==mip) {
+ if (res==kMip) {
qtot = fResponse->IntPH(eloss);
- Nfp = fResponse->FeedBackPhotons(global,qtot);
- } else if (res==cerenkov) {
+ nFp = fResponse->FeedBackPhotons(global,qtot);
+ } else if (res==kCerenkov) {
qtot = fResponse->IntPH();
- Nfp = fResponse->FeedBackPhotons(global,qtot);
+ nFp = fResponse->FeedBackPhotons(global,qtot);
}
- //printf("Feedbacks:%d\n",Nfp);
+ //printf("Feedbacks:%d\n",nFp);
//
// Loop Over Pads
}
+AliRICHChamber& AliRICHChamber::operator=(const AliRICHChamber& rhs)
+{
+// Assignment operator
+ return *this;
+
+}
-#ifndef AliRICHChamber_H
-#define AliRICHChamber_H
+#ifndef ALIRICHCHAMBER_H
+#define ALIRICHCHAMBER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
#include <TObjArray.h>
#include <TRotMatrix.h>
-#include "AliRICHSegRes.h"
+#include "AliRICHSegmentation.h"
+#include "AliRICHGeometry.h"
+#include "AliRICHResponse.h"
class AliRICHClusterFinder;
-class AliRICHResponse;
-class AliRICHSegmentation;
-class AliRICHGeometry;
-typedef enum {mip, cerenkov} Response_t;
+
+typedef enum {kMip, kCerenkov} ResponseType;
class AliRICHChamber : public TObject
{
public:
-//Rotation matrices for each chamber
-
- TRotMatrix *fChamberMatrix;
- Float_t fChamberTrans[3];
-
public:
AliRICHChamber();
+ AliRICHChamber(const AliRICHChamber & Chamber);
~AliRICHChamber(){}
//
// Set and get GEANT id
fGeometry->SetFreonThickness(thickness);
}
-
+ AliRICHChamber& operator=(const AliRICHChamber& rhs);
+
//
// Cluster formation method
- void DisIntegration(Float_t, Float_t, Float_t, Int_t&x, Float_t newclust[6][500], Response_t res);
+ void DisIntegration(Float_t eloss, Float_t xhit, Float_t yhit, Int_t&x, Float_t newclust[6][500], ResponseType res);
private:
// GEANT volume if for sensitive volume of this
-// Maximum and Minimum Chamber size
- Float_t frMin;
- Float_t frMax;
- Int_t fGid;
-// z-position of this chamber
- Float_t fzPos;
+ Float_t frMin; // Minimum Chamber size
+ Float_t frMax; // Maximum Chamber size
+ Int_t fGid; // Id tag
+ Float_t fzPos; // z-position of this chamber
// The segmentation models for the cathode planes
-// fnsec=1: one plane segmented, fnsec=2: both planes are segmented.
- Int_t fnsec;
+ Int_t fnsec; // fnsec=1: one plane segmented, fnsec=2: both planes are segmented.
- AliRICHSegmentation *fSegmentation;
- AliRICHResponse *fResponse;
- AliRICHGeometry *fGeometry;
- AliRICHClusterFinder *fReconstruction;
+ TRotMatrix *fChamberMatrix; //Rotation matrices for each chamber
+ Float_t fChamberTrans[3]; //Translaction vectors for each chamber
+
+ AliRICHSegmentation *fSegmentation; //Segmentation model for each chamber
+ AliRICHResponse *fResponse; //Response model for each chamber
+ AliRICHGeometry *fGeometry; //Geometry model for each chamber
+ AliRICHClusterFinder *fReconstruction; //Reconstruction model for each chamber
ClassDef(AliRICHChamber,1)
};
#endif
+
+
+
+
/*
$Log$
+ Revision 1.1 2000/04/19 13:01:48 morsch
+ A cluster finder and hit reconstruction class for RICH (adapted from MUON).
+ Cluster Finders for MUON and RICH should derive from the same class in the
+ future (JB, AM).
+
*/
#include "AliRICHClusterFinder.h"
-#include "TTree.h"
#include "AliRun.h"
+#include "AliRICH.h"
+#include "AliRICHHit.h"
+#include "AliRICHHitMapA1.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHPadHit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit.h"
+
+#include <TTree.h>
#include <TCanvas.h>
#include <TH1.h>
#include <TPad.h>
ClassImp(AliRICHClusterFinder)
- AliRICHClusterFinder::AliRICHClusterFinder
+AliRICHClusterFinder::AliRICHClusterFinder
(AliRICHSegmentation *segmentation, AliRICHResponse *response,
TClonesArray *digits, Int_t chamber)
{
+
+// Constructor for Cluster Finder object
+
fSegmentation=segmentation;
fResponse=response;
fNPeaks=-1;
}
- AliRICHClusterFinder::AliRICHClusterFinder()
+AliRICHClusterFinder::AliRICHClusterFinder()
{
+
+// Default constructor
+
fSegmentation=0;
fResponse=0;
fNPeaks=-1;
}
+AliRICHClusterFinder::AliRICHClusterFinder(const AliRICHClusterFinder& ClusterFinder)
+{
+// Copy Constructor
+}
+
+AliRICHClusterFinder::~AliRICHClusterFinder()
+{
+
+// Destructor
+
+delete fRawClusters;
+}
+
void AliRICHClusterFinder::AddRawCluster(const AliRICHRawCluster c)
{
//
// Add a raw cluster copy to the list
//
- AliRICH *RICH=(AliRICH*)gAlice->GetModule("RICH");
- RICH->AddRawCluster(fChamber,c);
+ AliRICH *pRICH=(AliRICH*)gAlice->GetModule("RICH");
+ pRICH->AddRawCluster(fChamber,c);
fNRawClusters++;
}
void AliRICHClusterFinder::Decluster(AliRICHRawCluster *cluster)
{
-// AliRICHDigit *dig;
-// Int_t q;
+//
+// Decluster algorithm
Int_t mul = cluster->fMultiplicity;
// printf("Decluster - multiplicity %d \n",mul);
Bool_t AliRICHClusterFinder::Centered(AliRICHRawCluster *cluster)
{
+
+// Is the cluster centered?
+
AliRICHDigit* dig;
dig= (AliRICHDigit*)fDigits->UncheckedAt(cluster->fIndexMap[0]);
Int_t ix=dig->fPadX;
Int_t iy=dig->fPadY;
Int_t nn;
- Int_t X[kMaxNeighbours], Y[kMaxNeighbours], XN[kMaxNeighbours], YN[kMaxNeighbours];
+ Int_t x[kMaxNeighbours], y[kMaxNeighbours], xN[kMaxNeighbours], yN[kMaxNeighbours];
- fSegmentation->Neighbours(ix,iy,&nn,X,Y);
+ fSegmentation->Neighbours(ix,iy,&nn,x,y);
Int_t nd=0;
for (Int_t i=0; i<nn; i++) {
- if (fHitMap->TestHit(X[i],Y[i]) == used) {
- XN[nd]=X[i];
- YN[nd]=Y[i];
+ if (fHitMap->TestHit(x[i],y[i]) == kUsed) {
+ yN[nd]=x[i];
+ yN[nd]=y[i];
nd++;
+
+ printf("Getting: %d %d %d\n",i,x[i],y[i]);
}
}
if (nd==2) {
// Highest signal on an edge, split cluster into 2+1
//
// who is the neighbour ?
- Int_t nind=fHitMap->GetHitIndex(XN[0], YN[0]);
+
+ printf("Calling GetIndex with x:%d y:%d\n",xN[0], yN[0]);
+
+ Int_t nind=fHitMap->GetHitIndex(xN[0], yN[0]);
Int_t i1= (nind==cluster->fIndexMap[1]) ? 1:2;
Int_t i2= (nind==cluster->fIndexMap[1]) ? 2:1;
//
}
void AliRICHClusterFinder::SplitByLocalMaxima(AliRICHRawCluster *c)
{
+
+//
+// Split the cluster according to the number of maxima inside
+
+
AliRICHDigit* dig[100], *digt;
Int_t ix[100], iy[100], q[100];
Float_t x[100], y[100];
//
// Find local maxima
//
- Bool_t IsLocal[100];
- Int_t NLocal=0;
- Int_t AssocPeak[100];
- Int_t IndLocal[100];
+ Bool_t isLocal[100];
+ Int_t nLocal=0;
+ Int_t associatePeak[100];
+ Int_t indLocal[100];
Int_t nn;
- Int_t X[kMaxNeighbours], Y[kMaxNeighbours];
+ Int_t xNei[kMaxNeighbours], yNei[kMaxNeighbours];
for (i=0; i<mul; i++) {
- fSegmentation->Neighbours(ix[i], iy[i], &nn, X, Y);
- IsLocal[i]=kTRUE;
+ fSegmentation->Neighbours(ix[i], iy[i], &nn, xNei, yNei);
+ isLocal[i]=kTRUE;
for (j=0; j<nn; j++) {
- if (fHitMap->TestHit(X[j], Y[j])==empty) continue;
- digt=(AliRICHDigit*) fHitMap->GetHit(X[j], Y[j]);
+ if (fHitMap->TestHit(xNei[j], yNei[j])==kEmpty) continue;
+ digt=(AliRICHDigit*) fHitMap->GetHit(xNei[j], yNei[j]);
if (digt->fSignal > q[i]) {
- IsLocal[i]=kFALSE;
+ isLocal[i]=kFALSE;
break;
//
// handle special case of neighbouring pads with equal signal
} else if (digt->fSignal == q[i]) {
- if (NLocal >0) {
- for (Int_t k=0; k<NLocal; k++) {
- if (X[j]==ix[IndLocal[k]] && Y[j]==iy[IndLocal[k]]){
- IsLocal[i]=kFALSE;
+ if (nLocal >0) {
+ for (Int_t k=0; k<nLocal; k++) {
+ if (xNei[j]==ix[indLocal[k]] && yNei[j]==iy[indLocal[k]]){
+ isLocal[i]=kFALSE;
}
}
}
}
} // loop over next neighbours
// Maxima should not be on the edge
- if (IsLocal[i]) {
- IndLocal[NLocal]=i;
- NLocal++;
+ if (isLocal[i]) {
+ indLocal[nLocal]=i;
+ nLocal++;
}
} // loop over all digits
-// printf("Found %d local Maxima",NLocal);
+// printf("Found %d local Maxima",nLocal);
//
// If only one local maximum found but multiplicity is high
// take global maximum from the list of digits.
- if (NLocal==1 && mul>5) {
+ if (nLocal==1 && mul>5) {
Int_t nnew=0;
for (i=0; i<mul; i++) {
- if (!IsLocal[i]) {
- IndLocal[NLocal]=i;
- IsLocal[i]=kTRUE;
- NLocal++;
+ if (!isLocal[i]) {
+ indLocal[nLocal]=i;
+ isLocal[i]=kTRUE;
+ nLocal++;
nnew++;
}
if (nnew==1) break;
}
// If number of local maxima is 2 try to fit a double gaussian
- if (NLocal==-100) {
+ if (nLocal==-100) {
//
// Initialise global variables for fit
gFirst=1;
// gMyMinuit->mnexcm("SET ERR",arglist,1,ierflag);
// Set starting values
static Double_t vstart[5];
- vstart[0]=x[IndLocal[0]];
- vstart[1]=y[IndLocal[0]];
- vstart[2]=x[IndLocal[1]];
- vstart[3]=y[IndLocal[1]];
- vstart[4]=Float_t(q[IndLocal[0]])/
- Float_t(q[IndLocal[0]]+q[IndLocal[1]]);
+ vstart[0]=x[indLocal[0]];
+ vstart[1]=y[indLocal[0]];
+ vstart[2]=x[indLocal[1]];
+ vstart[3]=y[indLocal[1]];
+ vstart[4]=Float_t(q[indLocal[0]])/
+ Float_t(q[indLocal[0]]+q[indLocal[1]]);
// lower and upper limits
static Double_t lower[5], upper[5];
- Int_t isec=fSegmentation->Sector(ix[IndLocal[0]], iy[IndLocal[0]]);
+ Int_t isec=fSegmentation->Sector(ix[indLocal[0]], iy[indLocal[0]]);
lower[0]=vstart[0]-fSegmentation->Dpx(isec)/2;
lower[1]=vstart[1]-fSegmentation->Dpy(isec)/2;
// lower[1]=vstart[1];
upper[1]=lower[1]+fSegmentation->Dpy(isec);
// upper[1]=vstart[1];
- isec=fSegmentation->Sector(ix[IndLocal[1]], iy[IndLocal[1]]);
+ isec=fSegmentation->Sector(ix[indLocal[1]], iy[indLocal[1]]);
lower[2]=vstart[2]-fSegmentation->Dpx(isec)/2;
lower[3]=vstart[3]-fSegmentation->Dpy(isec)/2;
// lower[3]=vstart[3];
Bool_t fitted=kTRUE;
- if (NLocal !=-100 || !fitted) {
+ if (nLocal !=-100 || !fitted) {
// Check if enough local clusters have been found,
// if not add global maxima to the list
//
Int_t nPerMax;
- if (NLocal!=0) {
- nPerMax=mul/NLocal;
+ if (nLocal!=0) {
+ nPerMax=mul/nLocal;
} else {
printf("\n Warning, no local maximum found \n");
nPerMax=fNperMax+1;
}
if (nPerMax > fNperMax) {
- Int_t nGlob=mul/fNperMax-NLocal+1;
+ Int_t nGlob=mul/fNperMax-nLocal+1;
if (nGlob > 0) {
Int_t nnew=0;
for (i=0; i<mul; i++) {
- if (!IsLocal[i]) {
- IndLocal[NLocal]=i;
- IsLocal[i]=kTRUE;
- NLocal++;
+ if (!isLocal[i]) {
+ indLocal[nLocal]=i;
+ isLocal[i]=kTRUE;
+ nLocal++;
nnew++;
}
if (nnew==nGlob) break;
for (i=0; i<mul; i++) {
Float_t dmin=1.E10;
Float_t qmax=0;
- if (IsLocal[i]) continue;
- for (j=0; j<NLocal; j++) {
- Int_t il=IndLocal[j];
+ if (isLocal[i]) continue;
+ for (j=0; j<nLocal; j++) {
+ Int_t il=indLocal[j];
Float_t d=TMath::Sqrt((x[i]-x[il])*(x[i]-x[il])
+(y[i]-y[il])*(y[i]-y[il]));
Float_t ql=q[il];
if (d<dmin) {
dmin=d;
qmax=ql;
- AssocPeak[i]=j;
+ associatePeak[i]=j;
} else if (d==dmin) {
//
// If more than one take highest peak
if (ql>qmax) {
dmin=d;
qmax=ql;
- AssocPeak[i]=j;
+ associatePeak[i]=j;
}
}
}
//
// One cluster for each maximum
//
- for (j=0; j<NLocal; j++) {
+ for (j=0; j<nLocal; j++) {
AliRICHRawCluster cnew;
if (fNPeaks == 0) {
cnew.fNcluster[0]=-1;
cnew.fNcluster[0]=fNPeaks;
cnew.fNcluster[1]=0;
}
- cnew.fIndexMap[0]=c->fIndexMap[IndLocal[j]];
+ cnew.fIndexMap[0]=c->fIndexMap[indLocal[j]];
cnew.fMultiplicity=1;
for (i=0; i<mul; i++) {
- if (IsLocal[i]) continue;
- if (AssocPeak[i]==j) {
+ if (isLocal[i]) continue;
+ if (associatePeak[i]==j) {
cnew.fIndexMap[cnew.fMultiplicity]=c->fIndexMap[i];
cnew.fMultiplicity++;
}
fSegmentation->GetPadIxy(x, y, ix, iy);
fSegmentation->GetPadCxy(ix, iy, x, y);
Int_t isec=fSegmentation->Sector(ix,iy);
- TF1* CogCorr = fSegmentation->CorrFunc(isec-1);
+ TF1* cogCorr = fSegmentation->CorrFunc(isec-1);
- if (CogCorr) {
- Float_t YonPad=(c->fY-y)/fSegmentation->Dpy(isec);
- c->fY=c->fY-CogCorr->Eval(YonPad, 0, 0);
+ if (cogCorr) {
+ Float_t yOnPad=(c->fY-y)/fSegmentation->Dpy(isec);
+ c->fY=c->fY-cogCorr->Eval(yOnPad, 0, 0);
}
}
}
// Now look recursively for all neighbours
//
Int_t nn;
- Int_t Xlist[kMaxNeighbours], Ylist[kMaxNeighbours];
- fSegmentation->Neighbours(i,j,&nn,Xlist,Ylist);
+ Int_t xList[kMaxNeighbours], yList[kMaxNeighbours];
+ fSegmentation->Neighbours(i,j,&nn,xList,yList);
for (Int_t in=0; in<nn; in++) {
- Int_t ix=Xlist[in];
- Int_t iy=Ylist[in];
- if (fHitMap->TestHit(ix,iy)==unused) FindCluster(ix, iy, c);
+ Int_t ix=xList[in];
+ Int_t iy=yList[in];
+ if (fHitMap->TestHit(ix,iy)==kUnused) FindCluster(ix, iy, c);
}
}
dig = (AliRICHDigit*)fDigits->UncheckedAt(ndig);
Int_t i=dig->fPadX;
Int_t j=dig->fPadY;
- if (fHitMap->TestHit(i,j)==used ||fHitMap->TestHit(i,j)==empty) {
+ if (fHitMap->TestHit(i,j)==kUsed ||fHitMap->TestHit(i,j)==kEmpty) {
nskip++;
continue;
}
fSegmentation->GetPadIxy(x, y, ix, iy);
fSegmentation->GetPadCxy(ix, iy, x, y);
Int_t isec=fSegmentation->Sector(ix,iy);
- TF1* CogCorr=fSegmentation->CorrFunc(isec-1);
- if (CogCorr) {
- Float_t YonPad=(c.fY-y)/fSegmentation->Dpy(isec);
- c.fY=c.fY-CogCorr->Eval(YonPad,0,0);
+ TF1* cogCorr=fSegmentation->CorrFunc(isec-1);
+ if (cogCorr) {
+ Float_t yOnPad=(c.fY-y)/fSegmentation->Dpy(isec);
+ c.fY=c.fY-cogCorr->Eval(yOnPad,0,0);
}
//
void AliRICHClusterFinder::
CalibrateCOG()
{
+
+// Calibration
+
Float_t x[5];
Float_t y[5];
Int_t n, i;
void AliRICHClusterFinder::
SinoidalFit(Float_t x, Float_t y, TF1 &func)
{
-//
+// Sinoidal fit
+
+
static Int_t count=0;
char canvasname[3];
count++;
sprintf(canvasname,"c%d",count);
- const Int_t ns=101;
- Float_t xg[ns], yg[ns], xrg[ns], yrg[ns];
- Float_t xsig[ns], ysig[ns];
+ const Int_t kNs=101;
+ Float_t xg[kNs], yg[kNs], xrg[kNs], yrg[kNs];
+ Float_t xsig[kNs], ysig[kNs];
AliRICHSegmentation *segmentation=fSegmentation;
//
// y-position
Float_t yscan=ymin;
- Float_t dy=segmentation->Dpy(isec)/(ns-1);
+ Float_t dy=segmentation->Dpy(isec)/(kNs-1);
- for (i=0; i<ns; i++) {
+ for (i=0; i<kNs; i++) {
//
// Pad Loop
//
//
// x-position
Float_t xscan=xmin;
- Float_t dx=segmentation->Dpx(isec)/(ns-1);
+ Float_t dx=segmentation->Dpx(isec)/(kNs-1);
- for (i=0; i<ns; i++) {
+ for (i=0; i<kNs; i++) {
//
// Pad Loop
//
// Creates a Root function based on function sinoid above
// and perform the fit
//
- // TGraph *graphx = new TGraph(ns,xg ,xsig);
- // TGraph *graphxr= new TGraph(ns,xrg,xsig);
- // TGraph *graphy = new TGraph(ns,yg ,ysig);
- TGraph *graphyr= new TGraph(ns,yrg,ysig);
+ // TGraph *graphx = new TGraph(kNs,xg ,xsig);
+ // TGraph *graphxr= new TGraph(kNs,xrg,xsig);
+ // TGraph *graphy = new TGraph(kNs,yg ,ysig);
+ TGraph *graphyr= new TGraph(kNs,yrg,ysig);
Double_t sinoid(Double_t *x, Double_t *par);
new TF1("sinoidf",sinoid,0.5,0.5,5);
Double_t sinoid(Double_t *x, Double_t *par)
{
+
+// Sinoid function
+
Double_t arg = -2*TMath::Pi()*x[0];
Double_t fitval= par[0]*TMath::Sin(arg)+
par[1]*TMath::Sin(2*arg)+
Double_t DoubleGauss(Double_t *x, Double_t *par)
{
+
+// Doublr gaussian function
+
Double_t arg1 = (x[0]-par[1])/0.18;
Double_t arg2 = (x[0]-par[3])/0.18;
Double_t fitval= par[0]*TMath::Exp(-arg1*arg1/2)
}
+void AliRICHClusterFinder::SetDigits(TClonesArray *RICHdigits)
+{
+
+// Get all the digits
+
+ fDigits=RICHdigits;
+ fNdigits = fDigits->GetEntriesFast();
+}
+
+AliRICHClusterFinder& AliRICHClusterFinder::operator=(const AliRICHClusterFinder& rhs)
+{
+// Assignment operator
+ return *this;
+
+}
+
-#ifndef AliRICHClusterFinder_H
-#define AliRICHClusterFinder_H
+#ifndef ALIRICHCLUSTERFINDER_H
+#define ALIRICHCLUSTERFINDER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
////////////////////////////////////////////////
// RICH Cluster Finder Class //
////////////////////////////////////////////////
-#include "AliRICHHitMap.h"
+class AliRICHHitMapA1;
+
#include "TF1.h"
+#include "TObject.h"
+class TClonesArray;
+class AliRICHSegmentation;
+class AliRICHRawCluster;
+class AliRICHResponse;
+class TClonesArray;
+
+
class AliRICHClusterFinder :
public TObject
{
-public:
- TClonesArray* fDigits;
- Int_t fNdigits;
-protected:
- AliRICHSegmentation* fSegmentation;
- AliRICHResponse* fResponse;
- TClonesArray* fRawClusters;
- Int_t fChamber;
- Int_t fNRawClusters;
- AliRICHHitMapA1* fHitMap;
- TF1* fCogCorr;
- Int_t fNperMax;
- Int_t fDeclusterFlag;
- Int_t fClusterSize;
- Int_t fNPeaks;
public:
AliRICHClusterFinder
(AliRICHSegmentation *segmentation,
AliRICHResponse *response, TClonesArray *digits, Int_t chamber);
AliRICHClusterFinder();
- ~AliRICHClusterFinder(){delete fRawClusters;}
+ AliRICHClusterFinder(const AliRICHClusterFinder & ClusterFinder);
+ virtual ~AliRICHClusterFinder();
virtual void SetSegmentation(
AliRICHSegmentation *segmentation){
fSegmentation=segmentation;
fResponse=response;
}
- virtual void SetDigits(TClonesArray *RICHdigits) {
- fDigits=RICHdigits;
- fNdigits = fDigits->GetEntriesFast();
- }
+ virtual void SetDigits(TClonesArray *RICHdigits);
virtual void SetChamber(Int_t ich){
fChamber=ich;
}
- virtual void AddRawCluster(const AliRICHRawCluster);
+ virtual void AddRawCluster(const AliRICHRawCluster c);
// Search for raw clusters
virtual void FindRawClusters();
virtual void FindCluster(Int_t i, Int_t j, AliRICHRawCluster &c);
//
virtual Bool_t Centered(AliRICHRawCluster *cluster);
virtual void SplitByLocalMaxima(AliRICHRawCluster *cluster);
- virtual void FillCluster(AliRICHRawCluster *cluster, Int_t);
+ virtual void FillCluster(AliRICHRawCluster *cluster, Int_t flag);
virtual void FillCluster(AliRICHRawCluster *cluster) {
FillCluster(cluster,1);}
TClonesArray* RawClusters(){return fRawClusters;}
+ AliRICHClusterFinder& operator=(const AliRICHClusterFinder& rhs);
ClassDef(AliRICHClusterFinder,1) //Class for clustering and reconstruction of space points
+protected:
+ AliRICHSegmentation* fSegmentation; //Segmentation model
+ AliRICHResponse* fResponse; //Response model
+ TClonesArray* fRawClusters; //Raw clusters list
+ Int_t fChamber; //Chamber number
+ Int_t fNRawClusters; //Number of raw clusters
+ AliRICHHitMapA1* fHitMap; //Hit Map with digit positions
+ TF1* fCogCorr; //Correction for center of gravity
+ Int_t fNperMax; //Number of pad hits per local maximum
+ Int_t fDeclusterFlag; //Split clusters flag
+ Int_t fClusterSize; //Size of cluster
+ Int_t fNPeaks; //Number of maxima in the cluster
+ TClonesArray* fDigits; //List of digits
+ Int_t fNdigits; //Number of digits
+
};
#endif
/*
$Log$
+ Revision 1.1 2000/04/19 13:05:14 morsch
+ J. Barbosa's spot reconstruction algorithm.
+
*/
#include "AliRICH.h"
#include "AliRICHPoints.h"
#include "AliRICHDetect.h"
-#include "DataStructures.h"
+#include "AliRICHHit.h"
+#include "AliRICHDigit.h"
#include "AliRun.h"
#include "TParticle.h"
#include "TMath.h"
//___________________________________________
AliRICHDetect::AliRICHDetect() : TObject()
{
+
+// Default constructor
+
//fChambers = 0;
}
: TObject()
{
+// Constructor
+
/*fChambers = new TObjArray(7);
for (Int_t i=0; i<7; i++) {
void AliRICHDetect::Detect()
{
+//
+// Detection algorithm
+
+
//printf("Detection started!\n");
Float_t OMEGA,steptheta,stepphi,x,y,cx,cy,l,aux1,aux2,aux3,maxi,maxj,maxk,max;
//Float_t theta,phi,realomega,realtheta;
//TTree *TR=gAlice->TreeR();
//Stat_t ndig=TR->GetEntries();
TClonesArray *fRec;
- for (i=0;i<7;i++) {
+ for (i=0;i<kNCH;i++) {
fRec=RICH->RecHitsAddress(i);
int ndig=fRec->GetEntriesFast();
printf ("Chamber %d, rings %d\n",i,ndig);
Float_t AliRICHDetect:: Area(Float_t theta,Float_t OMEGA)
{
-
+
+//
+// Calculates area of an ellipse for given incidence angles
+
+
Float_t area;
const Float_t h=9.25; //Distance from Radiator to Pads in pads
-#ifndef AliRICHDetect_H
-#define AliRICHDetect_H
+#ifndef ALIRICHDETECT_H
+#define ALIRICHDETECT_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHDigit.h"
+
+ClassImp(AliRICHDigit)
+//_____________________________________________________________________________
+AliRICHDigit::AliRICHDigit(Int_t *digits)
+{
+ //
+ // Creates a RICH digit object to be updated
+ //
+ fPadX = digits[0];
+ fPadY = digits[1];
+ fSignal = digits[2];
+
+}
+//_____________________________________________________________________________
+AliRICHDigit::AliRICHDigit(Int_t *tracks, Int_t *charges, Int_t *digits)
+{
+ //
+ // Creates a RICH digit object
+ //
+ fPadX = digits[0];
+ fPadY = digits[1];
+ fSignal = digits[2];
+ for(Int_t i=0; i<100; i++) {
+ fTcharges[i] = charges[i];
+ fTracks[i] = tracks[i];
+ }
+}
--- /dev/null
+#ifndef ALIRICHDIGIT_H
+#define ALIRICHDIGIT_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include "AliDigit.h"
+class AliRICHDigit : public TObject {
+ public:
+ Int_t fPadX; // Pad number along x
+ Int_t fPadY ; // Pad number along y
+ Int_t fSignal; // Signal amplitude
+
+
+ Int_t fTcharges[100]; // charge per track making this digit (up to 10)
+ Int_t fTracks[100]; // tracks making this digit (up to 10)
+ Int_t fPhysics; // physics contribution to signal
+ Int_t fHit; // hit number - temporary solution
+
+ public:
+ AliRICHDigit() {}
+ AliRICHDigit(Int_t *digits);
+ AliRICHDigit(Int_t *tracks, Int_t *charges, Int_t *digits);
+ virtual ~AliRICHDigit() {}
+ ClassDef(AliRICHDigit,1) //Digits for set:RICH
+};
+#endif
+
+
+
+
+
+
+
/*
$Log$
+ Revision 1.3 2000/06/09 14:52:08 jbarbosa
+ New tentative ellipse drawing routine
+
Revision 1.1 2000/04/19 13:07:45 morsch
Digits, clusters and reconstruction results added.
#include <TMath.h>
#include <TRandom.h>
#include <X3DBuffer.h>
+#include <TParticle.h>
#include "AliRun.h"
#include "AliPDG.h"
#include "AliRICHConst.h"
#include "AliRICHDisplay.h"
#include "AliRICHPoints.h"
-#include "TParticle.h"
+#include "AliRICHHit.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHPadHit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit.h"
+#include "AliRICHEllipse.h"
ClassImp(AliRICHDisplay)
//____________________________________________________________________________
AliRICHDisplay::AliRICHDisplay()
{
+
+// default constructor
+
fPoints = 0;
fPhits = 0;
fPCerenkovs = 0;
//_____________________________________________________________________________
void AliRICHDisplay::DisplayColorScale()
{
+
+// Draw the color scale in the RICH display canvas
Int_t i;
Int_t color;
if (gPad == fTrigPad) return 9999;
- const Int_t big = 9999;
- Int_t dist = big;
+ const Int_t kBig = 9999;
+ Int_t dist = kBig;
Float_t xmin = gPad->GetX1();
Float_t xmax = gPad->GetX2();
Float_t dx = 0.02*(xmax - xmin);
if (!fDrawCoG) return;
ResetRpoints();
- for (Int_t chamber=0;chamber<7;chamber++) {
+ for (Int_t chamber=0;chamber<kNCH;chamber++) {
LoadCoG(chamber,1);
}
if (!fDrawRecHits) return;
//ResetRecpoints();
- for (Int_t chamber=0;chamber<7;chamber++) {
+ for (Int_t chamber=0;chamber<kNCH;chamber++) {
LoadRecHits(chamber,1);
}
printf("Entering LoadCoG\n");
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetModule("RICH");
AliRICHChamber* iChamber;
- TClonesArray *RICHrawclust = RICH->RawClustAddress(chamber);
- printf ("Chamber:%d has adress:%p\n", chamber, RICHrawclust );
- if (RICHrawclust == 0) return;
+ TClonesArray *pRICHrawclust = pRICH->RawClustAddress(chamber);
+ printf ("Chamber:%d has adress:%p\n", chamber, pRICHrawclust );
+ if (pRICHrawclust == 0) return;
- RICH->ResetRawClusters();
+ pRICH->ResetRawClusters();
Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
gAlice->TreeR()->GetEvent(nent-1+cathode-1);
- Int_t nrawcl = RICHrawclust->GetEntriesFast();
+ Int_t nrawcl = pRICHrawclust->GetEntriesFast();
printf ("nrawcl:%d\n",nrawcl);
if (nrawcl == 0) return;
if (fRpoints == 0) fRpoints = new TObjArray(nrawcl);
- iChamber = &(RICH->Chamber(chamber));
+ iChamber = &(pRICH->Chamber(chamber));
AliRICHRawCluster *mRaw;
AliRICHPoints *points = 0;
//
//loop over all raw clusters and store their position
points = new AliRICHPoints(nrawcl);
for (Int_t iraw=0;iraw<nrawcl;iraw++) {
- mRaw = (AliRICHRawCluster*)RICHrawclust->UncheckedAt(iraw);
+ mRaw = (AliRICHRawCluster*)pRICHrawclust->UncheckedAt(iraw);
fRpoints->AddAt(points,iraw);
points->SetMarkerColor(3);
points->SetMarkerStyle(3);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(-1);
- Float_t VecLoc[3]={mRaw->fX,6.276,mRaw->fY};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- points->SetPoint(iraw,VecGlob[0],VecGlob[1],VecGlob[2]);
+ Float_t vectorLoc[3]={mRaw->fX,6.276,mRaw->fY};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points->SetPoint(iraw,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
}
}
//___________________________________________
printf("Entering LoadRecHits\n");
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetModule("RICH");
AliRICHChamber* iChamber;
- TClonesArray *RICHrechits = RICH->RecHitsAddress(chamber);
- printf ("Chamber:%d has adress:%p\n", chamber, RICHrechits );
- if (RICHrechits == 0) return;
+ TClonesArray *pRICHrechits = pRICH->RecHitsAddress(chamber);
+ printf ("Chamber:%d has adress:%p\n", chamber, pRICHrechits );
+ if (pRICHrechits == 0) return;
//RICH->ResetRecHits();
Int_t nent=(Int_t)gAlice->TreeR()->GetEntries();
gAlice->TreeR()->GetEvent(nent-1+cathode-1);
- Int_t nrechits = RICHrechits->GetEntriesFast();
+ Int_t nrechits = pRICHrechits->GetEntriesFast();
printf ("nrechits:%d\n",nrechits);
if (nrechits == 0) return;
if (fRecpoints == 0) fRecpoints = new TObjArray(50);
- iChamber = &(RICH->Chamber(chamber));
+ iChamber = &(pRICH->Chamber(chamber));
AliRICHRecHit *mRec;
AliRICHPoints *points = 0;
//AliRICHEllipse *ellipse = 0;
points = new AliRICHPoints(nrechits);
for (Int_t irec=0;irec<nrechits;irec++) {
- mRec = (AliRICHRecHit*)RICHrechits->UncheckedAt(irec);
+ mRec = (AliRICHRecHit*)pRICHrechits->UncheckedAt(irec);
fRecpoints->AddAt(points,irec);
points->SetMarkerColor(38);
points->SetMarkerStyle(8);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(-1);
- Float_t VecLoc[3]={mRec->fX,6.276,mRec->fY};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- points->SetPoint(irec,VecGlob[0],VecGlob[1],VecGlob[2]);
+ Float_t vectorLoc[3]={mRec->fX,6.276,mRec->fY};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points->SetPoint(irec,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
//Float_t theta = iChamber->GetRotMatrix()->GetTheta();
//Float_t phi = iChamber->GetRotMatrix()->GetPhi();
- //ellipse=new TEllipse(VecGlob[0],VecGlob[2],10,10,0,360,phi);
+ //ellipse=new TEllipse(vectorGlob[0],vectorGlob[2],10,10,0,360,phi);
printf("Generating ellipse %d\n",irec);
- AliRICHEllipse *ellipse=new AliRICHEllipse(mRec->fX,mRec->fY,mRec->Omega,mRec->Theta,mRec->Phi);
+ AliRICHEllipse *ellipse=new AliRICHEllipse(mRec->fX,mRec->fY,mRec->fOmega,mRec->fTheta,mRec->fPhi);
ellipse->CreatePoints(chamber);
//ellipse->SetFillStyle(1001);
ellipse->SetMarkerColor(38);
// Loop on all detectors
ResetPoints();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
AliRICHSegmentation* segmentation;
- Int_t NallDigits=0;
+ Int_t nAllDigits=0;
Int_t ich;
- for (ich=0; ich<7; ich++) {
- TClonesArray *RICHdigits = RICH->DigitsAddress(ich);
- if (RICHdigits == 0) continue;
+ for (ich=0; ich<kNCH; ich++) {
+ TClonesArray *pRICHdigits = pRICH->DigitsAddress(ich);
+ if (pRICHdigits == 0) continue;
gAlice->ResetDigits();
gAlice->TreeD()->GetEvent(1);
- Int_t ndigits = RICHdigits->GetEntriesFast();
- NallDigits+=ndigits;
+ Int_t ndigits = pRICHdigits->GetEntriesFast();
+ nAllDigits+=ndigits;
}
- if (fPoints == 0) fPoints = new TObjArray(NallDigits);
+ if (fPoints == 0) fPoints = new TObjArray(nAllDigits);
Int_t counter=0;
- for (ich=0; ich<7; ich++) {
- TClonesArray *RICHdigits = RICH->DigitsAddress(ich);
- if (RICHdigits == 0) continue;
+ for (ich=0; ich<kNCH; ich++) {
+ TClonesArray *pRICHdigits = pRICH->DigitsAddress(ich);
+ if (pRICHdigits == 0) continue;
gAlice->ResetDigits();
gAlice->TreeD()->GetEvent(1);
- Int_t ndigits = RICHdigits->GetEntriesFast();
+ Int_t ndigits = pRICHdigits->GetEntriesFast();
if (ndigits == 0) continue;
- iChamber = &(RICH->Chamber(ich));
+ iChamber = &(pRICH->Chamber(ich));
segmentation=iChamber->GetSegmentationModel();
Float_t dpx = segmentation->Dpx();
Float_t dpy = segmentation->Dpy();
Int_t npoints=1;
for (Int_t digit=0;digit<ndigits;digit++) {
- mdig = (AliRICHDigit*)RICHdigits->UncheckedAt(digit);
+ mdig = (AliRICHDigit*)pRICHdigits->UncheckedAt(digit);
points = new AliRICHPoints(npoints);
fPoints->AddAt(points,counter);
counter++;
points->SetMarkerSize(0.5);
Float_t xpad, ypad;
segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY,xpad, ypad);
- Float_t VecLoc[3]={xpad,6.276,ypad};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
+ Float_t vectorLoc[3]={xpad,6.276,ypad};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
points->SetParticle(-1);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(digit);
- points->SetPoint(0,VecGlob[0],VecGlob[1],VecGlob[2]);
+ points->SetPoint(0,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY, xpad, ypad);
Float_t theta = iChamber->GetRotMatrix()->GetTheta();
Float_t phi = iChamber->GetRotMatrix()->GetPhi();
- marker=new TMarker3DBox(VecGlob[0],VecGlob[1],VecGlob[2],
+ marker=new TMarker3DBox(vectorGlob[0],vectorGlob[1],vectorGlob[2],
dpy/2,0,dpx/2,theta,phi);
marker->SetLineColor(2);
marker->SetFillStyle(1001);
fChamber=chamber;
ResetPhits();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
- iChamber = &(RICH->Chamber(chamber-1));
+ iChamber = &(pRICH->Chamber(chamber-1));
Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
Int_t track;
//TVector *zp = new TVector(1000);
//TVector *ptrk = new TVector(1000);
//TVector *phit = new TVector(1000);
- Int_t NallHits=0;
+ Int_t nAllHits=0;
for (track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHhits = RICH->Hits();
- if (RICHhits == 0) return;
- Int_t nhits = RICHhits->GetEntriesFast();
- NallHits+=nhits;
+ TClonesArray *pRICHhits = pRICH->Hits();
+ if (pRICHhits == 0) return;
+ Int_t nhits = pRICHhits->GetEntriesFast();
+ nAllHits+=nhits;
}
- fPhits = new TObjArray(NallHits);
+ fPhits = new TObjArray(nAllHits);
Int_t npoints=0;
for (track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHhits = RICH->Hits();
- if (RICHhits == 0) return;
- Int_t nhits = RICHhits->GetEntriesFast();
+ TClonesArray *pRICHhits = pRICH->Hits();
+ if (pRICHhits == 0) return;
+ Int_t nhits = pRICHhits->GetEntriesFast();
if (nhits == 0) continue;
AliRICHHit *mHit;
AliRICHPoints *points = 0;
for (Int_t hit=0;hit<nhits;hit++) {
points = new AliRICHPoints(1);
fPhits->AddAt(points,npoints);
- mHit = (AliRICHHit*)RICHhits->UncheckedAt(hit);
+ mHit = (AliRICHHit*)pRICHhits->UncheckedAt(hit);
TParticle *current =
(TParticle*)(*gAlice->Particles())[mHit->fTrack];
if (current->GetPdgCode() == 50000050) {
fChamber=chamber;
ResetPCerenkovs();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
- iChamber = &(RICH->Chamber(chamber-1));
+ iChamber = &(pRICH->Chamber(chamber-1));
- RICH->SetTreeAddress();
+ pRICH->SetTreeAddress();
Int_t ntracks = (Int_t)gAlice->TreeH()->GetEntries();
if (fPCerenkovs == 0) fPCerenkovs = new TObjArray(ntracks);
for (Int_t track=0; track<ntracks;track++) {
gAlice->ResetHits();
gAlice->TreeH()->GetEvent(track);
- TClonesArray *RICHCerenkovs = RICH->Cerenkovs();
- if (RICHCerenkovs == 0) return;
- Int_t nhits = RICHCerenkovs->GetEntriesFast();
+ TClonesArray *pRICHCerenkovs = pRICH->Cerenkovs();
+ if (pRICHCerenkovs == 0) return;
+ Int_t nhits = pRICHCerenkovs->GetEntriesFast();
if (nhits == 0) continue;
AliRICHCerenkov *mCerenkov;
AliRICHPoints *cpoints = 0;
//Display Cerenkov hits in blue
for (Int_t hit=0;hit<nhits;hit++) {
- mCerenkov = (AliRICHCerenkov*)RICHCerenkovs->UncheckedAt(hit);
+ mCerenkov = (AliRICHCerenkov*)pRICHCerenkovs->UncheckedAt(hit);
(*xp)(npoints)=mCerenkov->fX;
(*yp)(npoints)=mCerenkov->fY;
(*zp)(npoints)=mCerenkov->fZ;
//_____________________________________________________________________________
void AliRICHDisplay::SetPickMode()
{
+
+// Toggle pick mode
+
fZoomMode = 0;
fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
//_____________________________________________________________________________
void AliRICHDisplay::SetZoomMode()
{
+
+// Toggle Zoom mode
+
fZoomMode = 1;
fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
if (delta) {
gAlice->Clear();
- Int_t current_event = gAlice->GetHeader()->GetEvent();
- Int_t new_event = current_event + delta;
- gAlice->GetEvent(new_event);
+ Int_t currentEvent = gAlice->GetHeader()->GetEvent();
+ Int_t newEvent = currentEvent + delta;
+ gAlice->GetEvent(newEvent);
if (!gAlice->TreeD()) return;
}
LoadDigits();
//______________________________________________________________________________
void AliRICHDisplay::UnZoom()
{
+
+// Return to previous zoom factor
+
if (fZooms <= 0) return;
fZooms--;
TPad *pad = (TPad*)gPad->GetPadSave();
if (!view) return;
pad->x3d();
}
-
-
-
-
-ClassImp(AliRICHEllipse)
-
-//________________________________________________________________________________
-AliRICHEllipse::AliRICHEllipse()
-{
- fCx = 0;
- fCy = 0;
- fOmega = 0;
- fTheta = 0;
- fPhi = 0;
- h= 0;
-}
-
-//________________________________________________________________________________
-AliRICHEllipse::~AliRICHEllipse()
-{
- fCx = 0;
- fCy = 0;
- fOmega = 0;
- fTheta = 0;
- fPhi = 0;
- h= 0;
-}
-
-
-//________________________________________________________________________________
-AliRICHEllipse::AliRICHEllipse(Float_t cx, Float_t cy, Float_t omega, Float_t theta, Float_t phi)
-{
- fCx = cx;
- fCy = cy;
- fOmega = omega;
- fTheta = theta;
- fPhi = phi;
- h=11.25;
-}
-
-//________________________________________________________________________________
-void AliRICHEllipse::CreatePoints(Int_t chamber)
-{
- Int_t s1,s2;
- Float_t fiducial=h*TMath::Tan(fOmega+fTheta), l=h/TMath::Cos(fTheta), xtrial, y, c0, c1, c2;
- //TRandom *random=new TRandom();
-
- AliRICH *RICH = (AliRICH*)gAlice->GetModule("RICH");
- AliRICHChamber* iChamber;
-
- iChamber = &(RICH->Chamber(chamber));
- //cout<<"fiducial="<<fiducial<<endl;
-
- for(Float_t i=0;i<1000;i++)
- {
-
- Float_t counter=0;
-
- c0=0;c1=0;c2=0;
- while((c1*c1-4*c2*c0)<=0 && counter<1000)
- {
- //Choose which side to go...
- if(i>250 && i<750) s1=1;
- //if (gRandom->Rndm(1)>.5) s1=1;
- else s1=-1;
- //printf("s1:%d\n",s1);
- //Trial a y
- y=s1*i*gRandom->Rndm(Int_t(fiducial/50));
- //printf("Fiducial %f for omega:%f theta:%f phi:%f\n",fiducial,fOmega,fTheta,fPhi);
- Float_t alfa1=fTheta;
- Float_t theta1=fPhi;
- Float_t OMEGA1=fOmega;
-
- //Solve the eq for a trial x
- c0=-TMath::Power(y*TMath::Cos(alfa1)*TMath::Cos(theta1),2)-TMath::Power(y*TMath::Sin(alfa1),2)+TMath::Power(l*TMath::Tan(OMEGA1),2)+2*l*y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(OMEGA1),2)+TMath::Power(y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Tan(OMEGA1),2);
- c1=2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)-2*y*TMath::Cos(alfa1)*TMath::Power(TMath::Cos(theta1),2)*TMath::Sin(alfa1)+2*l*TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(OMEGA1),2)+2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)*TMath::Power(TMath::Sin(theta1),2)*TMath::Power(TMath::Tan(OMEGA1),2);
- c2=-TMath::Power(TMath::Cos(alfa1),2)-TMath::Power(TMath::Cos(theta1)*TMath::Sin(alfa1),2)+TMath::Power(TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Tan(OMEGA1),2);
- //cout<<"Trial: y="<<y<<"c0="<<c0<<" c1="<<c1<<" c2="<<c2<<endl;
- //printf("Result:%f\n\n",c1*c1-4*c2*c0);
- //i+=.01;
- counter +=1;
- }
-
- if (counter>=1000)
- y=0;
-
- //Choose which side to go...
- //if(gRandom->Rndm(1)>.5) s=1;
- //else s=-1;
- if(i>500) s2=1;
- //if (gRandom->Rndm(1)>.5) s2=1;
- else s2=-1;
- xtrial=fCx+(-c1+s2*TMath::Sqrt(c1*c1-4*c2*c0))/(2*c2);
- //cout<<"x="<<xtrial<<" y="<<cy+y<<endl;
- //printf("Coordinates: %f %f\n",xtrial,fCy+y);
-
- Float_t VecLoc[3]={xtrial,6.276,(fCy+y)};
- Float_t VecGlob[3];
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- SetPoint(i,VecGlob[0],VecGlob[1],VecGlob[2]);
- //printf("Coordinates: %f %f %f\n",VecGlob[0],VecGlob[1],VecGlob[2]);
- }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#ifndef AliRICHDisplay_H
-#define AliRICHDisplay_H
+#ifndef ALIRICHDISPLAY_H
+#define ALIRICHDISPLAY_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
const Int_t kMAXZOOM = 20;
-class AliRICHDisplay : /*splaypublic TObject,*/ public AliDisplay {
-
- private:
- Int_t fChamber;
- Int_t fCathode;
- Int_t fZoomMode; //=1 if in zoom mode
-
- Bool_t fDrawClusters; //Flag True if Clusters to be drawn
- Bool_t fDrawCoG; //Flag True if CoG to be drawn
- Bool_t fDrawRecHits; //Flag True if rec hits to be drawn
- Float_t fTheta; //Viewing angle theta
- Float_t fPhi; //Viewing angle phi
- Float_t fPsi; //Viewving angle psi (rotation on display)
- Float_t fRrange; //Size of view in R
- Float_t fZrange; //Size of view along Z
- Float_t fZoomX0[20]; //Low x range of zoom number i
- Float_t fZoomY0[20]; //Low y range of zoom number i
- Float_t fZoomX1[20]; //High x range of zoom number i
- Float_t fZoomY1[20]; //High y range of zoom number i
- Int_t fZooms; //Number of zooms
- Int_t fHitsCuts; //Number of hits surviving cuts
- Int_t fClustersCuts; //Number of clusters surviving cuts
- TCanvas *fCanvas; //Pointer to the display canvas
- TPad *fTrigPad; //Pointer to the trigger pad
- TPad *fColPad; //Pointer to the colors pad
- TPad *fButtons; //Pointer to the buttons pad
- TPad *fPad; //Pointer to the event display main pad
- TSlider *fRangeSlider; //Range slider
- TButton *fPickButton; //Button to activate Pick mode
- TButton *fZoomButton; //Button to activate Zoom mode
- TArc *fArcButton; //Gren/Red button to show Pick/Zoom mode
- TObjArray *fPoints; //Array of points for each cathode
- TObjArray *fPhits; //Array of hit points for each chamber
- TObjArray *fPCerenkovs; //Array of cerenkov hits for each chamber
- TObjArray *fRpoints; //Array of cog points for each cathode
- TObjArray *fRecpoints; //Array of rec points for each cathode
-
+class AliRICHDisplay : public AliDisplay {
public:
AliRICHDisplay();
AliRICHDisplay(Int_t size);
virtual void ResetRecpoints();
virtual void ResetPhits();
virtual void ResetPCerenkovs();
- ClassDef(AliRICHDisplay, 0) //Utility class to display RICH clusters...
-};
-
-
-class AliRICHEllipse : public TPolyMarker3D {
-
-public:
- AliRICHEllipse();
- AliRICHEllipse(Float_t cx, Float_t cy, Float_t omega, Float_t theta, Float_t phi);
+ private:
+ Int_t fChamber; //Chamber number
+ Int_t fCathode; //Cathode number
+ Int_t fZoomMode; //=1 if in zoom mode
- virtual ~AliRICHEllipse();
- virtual void CreatePoints(Int_t chamber);
-
- Float_t fOmega;
- Float_t fTheta;
- Float_t fPhi;
- Float_t fCx;
- Float_t fCy;
- Float_t h;
-
- ClassDef(AliRICHEllipse, 1) //Utility class to draw an ellipse
-};
+ Bool_t fDrawClusters; //Flag True if Clusters to be drawn
+ Bool_t fDrawCoG; //Flag True if CoG to be drawn
+ Bool_t fDrawRecHits; //Flag True if rec hits to be drawn
+ Float_t fTheta; //Viewing angle theta
+ Float_t fPhi; //Viewing angle phi
+ Float_t fPsi; //Viewving angle psi (rotation on display)
+ Float_t fRrange; //Size of view in R
+ Float_t fZrange; //Size of view along Z
+ Float_t fZoomX0[20]; //Low x range of zoom number i
+ Float_t fZoomY0[20]; //Low y range of zoom number i
+ Float_t fZoomX1[20]; //High x range of zoom number i
+ Float_t fZoomY1[20]; //High y range of zoom number i
+ Int_t fZooms; //Number of zooms
+ Int_t fHitsCuts; //Number of hits surviving cuts
+ Int_t fClustersCuts; //Number of clusters surviving cuts
+ TCanvas *fCanvas; //Pointer to the display canvas
+ TPad *fTrigPad; //Pointer to the trigger pad
+ TPad *fColPad; //Pointer to the colors pad
+ TPad *fButtons; //Pointer to the buttons pad
+ TPad *fPad; //Pointer to the event display main pad
+ TSlider *fRangeSlider; //Range slider
+ TButton *fPickButton; //Button to activate Pick mode
+ TButton *fZoomButton; //Button to activate Zoom mode
+ TArc *fArcButton; //Gren/Red button to show Pick/Zoom mode
+ TObjArray *fPoints; //Array of points for each cathode
+ TObjArray *fPhits; //Array of hit points for each chamber
+ TObjArray *fPCerenkovs; //Array of cerenkov hits for each chamber
+ TObjArray *fRpoints; //Array of cog points for each cathode
+ TObjArray *fRecpoints; //Array of rec points for each cathode
+ ClassDef(AliRICHDisplay, 0) //Utility class to display RICH clusters...
+};
#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+#include "AliRICHEllipse.h"
+#include "AliRICH.h"
+#include "AliRun.h"
+
+#include <TRandom.h>
+
+ClassImp(AliRICHEllipse)
+
+//________________________________________________________________________________
+AliRICHEllipse::AliRICHEllipse()
+{
+
+// Default Constructor for a RICH ellipse
+
+ fCx = 0;
+ fCy = 0;
+ fOmega = 0;
+ fTheta = 0;
+ fPhi = 0;
+ fh= 0;
+}
+
+//________________________________________________________________________________
+AliRICHEllipse::~AliRICHEllipse()
+{
+
+// Destructor
+
+ fCx = 0;
+ fCy = 0;
+ fOmega = 0;
+ fTheta = 0;
+ fPhi = 0;
+ fh= 0;
+}
+
+
+//________________________________________________________________________________
+AliRICHEllipse::AliRICHEllipse(Float_t cx, Float_t cy, Float_t omega, Float_t theta, Float_t phi)
+{
+
+// Constructor for a RICH ellipse
+
+ fCx = cx;
+ fCy = cy;
+ fOmega = omega;
+ fTheta = theta;
+ fPhi = phi;
+ fh=11.25;
+}
+
+//________________________________________________________________________________
+void AliRICHEllipse::CreatePoints(Int_t chamber)
+{
+
+// Create points along the ellipse equation
+
+ Int_t s1,s2;
+ Float_t fiducial=fh*TMath::Tan(fOmega+fTheta), l=fh/TMath::Cos(fTheta), xtrial, y=0, c0, c1, c2;
+ //TRandom *random=new TRandom();
+
+ AliRICH *pRICH = (AliRICH*)gAlice->GetModule("RICH");
+ AliRICHChamber* iChamber;
+
+ iChamber = &(pRICH->Chamber(chamber));
+ //cout<<"fiducial="<<fiducial<<endl;
+
+ for(Float_t i=0;i<1000;i++)
+ {
+
+ Float_t counter=0;
+
+ c0=0;c1=0;c2=0;
+ while((c1*c1-4*c2*c0)<=0 && counter<1000)
+ {
+ //Choose which side to go...
+ if(i>250 && i<750) s1=1;
+ //if (gRandom->Rndm(1)>.5) s1=1;
+ else s1=-1;
+ //printf("s1:%d\n",s1);
+ //Trial a y
+ y=s1*i*gRandom->Rndm(Int_t(fiducial/50));
+ //printf("Fiducial %f for omega:%f theta:%f phi:%f\n",fiducial,fOmega,fTheta,fPhi);
+ Float_t alfa1=fTheta;
+ Float_t theta1=fPhi;
+ Float_t omega1=fOmega;
+
+ //Solve the eq for a trial x
+ c0=-TMath::Power(y*TMath::Cos(alfa1)*TMath::Cos(theta1),2)-TMath::Power(y*TMath::Sin(alfa1),2)+TMath::Power(l*TMath::Tan(omega1),2)+2*l*y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(omega1),2)+TMath::Power(y*TMath::Cos(alfa1)*TMath::Sin(theta1)*TMath::Tan(omega1),2);
+ c1=2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)-2*y*TMath::Cos(alfa1)*TMath::Power(TMath::Cos(theta1),2)*TMath::Sin(alfa1)+2*l*TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Power(TMath::Tan(omega1),2)+2*y*TMath::Cos(alfa1)*TMath::Sin(alfa1)*TMath::Power(TMath::Sin(theta1),2)*TMath::Power(TMath::Tan(omega1),2);
+ c2=-TMath::Power(TMath::Cos(alfa1),2)-TMath::Power(TMath::Cos(theta1)*TMath::Sin(alfa1),2)+TMath::Power(TMath::Sin(alfa1)*TMath::Sin(theta1)*TMath::Tan(omega1),2);
+ //cout<<"Trial: y="<<y<<"c0="<<c0<<" c1="<<c1<<" c2="<<c2<<endl;
+ //printf("Result:%f\n\n",c1*c1-4*c2*c0);
+ //i+=.01;
+ counter +=1;
+ }
+
+ if (counter>=1000)
+ y=0;
+
+ //Choose which side to go...
+ //if(gRandom->Rndm(1)>.5) s=1;
+ //else s=-1;
+ if(i>500) s2=1;
+ //if (gRandom->Rndm(1)>.5) s2=1;
+ else s2=-1;
+ xtrial=fCx+(-c1+s2*TMath::Sqrt(c1*c1-4*c2*c0))/(2*c2);
+ //cout<<"x="<<xtrial<<" y="<<cy+y<<endl;
+ //printf("Coordinates: %f %f\n",xtrial,fCy+y);
+
+ Float_t vectorLoc[3]={xtrial,6.276,(fCy+y)};
+ Float_t vectorGlob[3];
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ SetPoint(i,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
+ //printf("Coordinates: %f %f %f\n",vectorGlob[0],vectorGlob[1],vectorGlob[2]);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+#ifndef ALIRICHELLIPSE_H
+#define ALIRICHELLIPSE_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include <TPolyMarker3D.h>
+
+class AliRICHEllipse : public TPolyMarker3D {
+
+ public:
+ AliRICHEllipse();
+ AliRICHEllipse(Float_t cx, Float_t cy, Float_t omega, Float_t theta, Float_t phi);
+
+ virtual ~AliRICHEllipse();
+ virtual void CreatePoints(Int_t chamber);
+ private:
+ Float_t fOmega; //Cherenkov angle
+ Float_t fTheta; //Incidence angle (dip angle)
+ Float_t fPhi; //Incidence angle
+ Float_t fCx; //Hit coordinate-x
+ Float_t fCy; //Hit coordinate-y
+ Float_t fh; //Distance from radiator to pads
+
+ ClassDef(AliRICHEllipse, 1) //Utility class to draw an ellipse
+};
+#endif
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+#include "AliRICHGeometry.h"
+
+ClassImp(AliRICHGeometry)
--- /dev/null
+#ifndef ALIRICHGEOMETRY_H
+#define ALIRICHGEOMETRY_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include <TObject.h>
+
+
+class AliRICHGeometry : //Chamber geometry
+public TObject {
+ public:
+ // Radiator Thickness
+ void SetGapThickness(Float_t thickness) {fGapThickness=thickness;}
+ // Proximity Gap Thickness
+ void SetProximityGapThickness(Float_t thickness) {fProximityGapThickness=thickness;}
+ // Quartz Length
+ void SetQuartzLength(Float_t length) {fQuartzLength=length;}
+ // Quartz Width
+ void SetQuartzWidth(Float_t width) {fQuartzWidth=width;}
+ // Quartz Thickness
+ void SetQuartzThickness(Float_t thickness) {fQuartzThickness=thickness;}
+ // Freon Length
+ void SetOuterFreonLength(Float_t length) {fOuterFreonLength=length;}
+ // Freon Width
+ void SetOuterFreonWidth(Float_t width) {fOuterFreonWidth=width;}
+ // Freon Length
+ void SetInnerFreonLength(Float_t length) {fInnerFreonLength=length;}
+ // Freon Width
+ void SetInnerFreonWidth(Float_t width) {fInnerFreonWidth=width;}
+ // Freon Thickness
+ void SetFreonThickness(Float_t thickness) {fFreonThickness=thickness;}
+ // Freon Thickness
+ void SetRadiatorToPads(Float_t distance) {fRadiatorToPads=distance;}
+
+ // Radiator thickness
+ Float_t GetGapThickness() {return fGapThickness;}
+ // Proximity Gap thickness
+ Float_t GetProximityGapThickness() {return fProximityGapThickness;}
+ // Quartz Length
+ Float_t GetQuartzLength() {return fQuartzLength;}
+ // Quartz Width
+ Float_t GetQuartzWidth() {return fQuartzWidth;}
+ // Quartz Thickness
+ Float_t GetQuartzThickness() {return fQuartzThickness;}
+ // Freon Length
+ Float_t GetOuterFreonLength() {return fOuterFreonLength;}
+ // Freon Width
+ Float_t GetOuterFreonWidth() {return fOuterFreonWidth;}
+ // Freon Length
+ Float_t GetInnerFreonLength() {return fInnerFreonLength;}
+ // Freon Width
+ Float_t GetInnerFreonWidth() {return fInnerFreonWidth;}
+ // Freon Thickness
+ Float_t GetFreonThickness() {return fFreonThickness;}
+ // Get distance between radiator and pads
+ Float_t GetRadiatorToPads() {return fRadiatorToPads;}
+
+ private:
+ Float_t fGapThickness; // Gap Thickness
+ Float_t fProximityGapThickness; // Proximity Gap Thickness
+ Float_t fQuartzLength; // Quartz Length
+ Float_t fQuartzWidth; // Quartz Width
+ Float_t fQuartzThickness; // Quartz Thickness
+ Float_t fOuterFreonLength; // Outer Freon Length
+ Float_t fOuterFreonWidth; // Outer Freon Width
+ Float_t fInnerFreonLength; // Inner Freon Length
+ Float_t fInnerFreonWidth; // Inner Freon Width
+ Float_t fFreonThickness; // Freon Thickness
+ Float_t fRadiatorToPads; // Distance from radiator to pads
+
+ ClassDef(AliRICHGeometry,1)
+};
+#endif
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHHit.h"
+ClassImp(AliRICHHit)
+//___________________________________________
+AliRICHHit::AliRICHHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
+ AliHit(shunt, track)
+{
+// Constructor
+ fChamber=vol[0];
+ fParticle=hits[0];
+ fX=hits[1];
+ fY=hits[2];
+ fZ=hits[3];
+ fTheta=hits[4];
+ fPhi=hits[5];
+ fTlength=hits[6];
+ fEloss=hits[7];
+ fPHfirst=(Int_t) hits[8];
+ fPHlast=(Int_t) hits[9];
+ fLoss=hits[13];
+ fMomX=hits[14];
+ fMomY=hits[15];
+ fMomZ=hits[16];
+ fNPads=hits[17];
+}
--- /dev/null
+#ifndef ALIRICHHIT_H
+#define ALIRICHHIT_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+
+#include "AliHit.h"
+
+class AliRICHHit : public AliHit {
+ public:
+ Int_t fChamber; // Chamber number
+ Float_t fParticle; // Geant3 particle type
+ Float_t fTheta ; // Incident theta angle in degrees
+ Float_t fPhi ; // Incident phi angle in degrees
+ Float_t fTlength; // Track length inside the chamber
+ Float_t fEloss; // ionisation energy loss in gas
+ Float_t fPHfirst; // first padhit
+ Float_t fPHlast; // last padhit
+ Float_t fLoss; // did it hit the freon?
+ Float_t fMomX; // Local Momentum
+ Float_t fMomY; // Local Momentum
+ Float_t fMomZ; // Local Momentum
+ Float_t fNPads; // Pads hit
+ public:
+ AliRICHHit() {}
+ AliRICHHit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
+ virtual ~AliRICHHit() {}
+
+ ClassDef(AliRICHHit,1) //Hits object for set:RICH
+};
+#endif
/*
$Log$
+ Revision 1.4 2000/04/19 13:14:36 morsch
+ Minor changes on class names.
+
*/
#include "AliRICHHitMap.h"
ClassImp(AliRICHHitMap)
-ClassImp(AliRICHHitMapA1)
-
-
-AliRICHHitMapA1::AliRICHHitMapA1(AliRICHSegmentation *seg, TObjArray *dig)
-{
- fSegmentation = seg;
- fNpx = fSegmentation->Npx();
- fNpy = fSegmentation->Npy();
- fMaxIndex=2*(fNpx+1)*2*(fNpy+1)+2*fNpy;
-
- fHitMap = new Int_t[fMaxIndex];
- fDigits = dig;
- fNdigits = fDigits->GetEntriesFast();
- Clear();
-}
-
-
-AliRICHHitMapA1::~AliRICHHitMapA1()
-{
-// if (fDigits) delete fDigits;
- if (fHitMap) delete[] fHitMap;
-}
-
-void AliRICHHitMapA1::Clear()
-{
- memset(fHitMap,0,sizeof(int)*fMaxIndex);
-}
-
-Int_t AliRICHHitMapA1::CheckedIndex(Int_t ix, Int_t iy)
-{
- Int_t index=2*fNpy*(ix+fNpx)+(iy+fNpy);
- if (index > fMaxIndex) {
- printf("\n \n \n Try to read/write outside array !!!! \n \n %d %d %d %d %d %d",ix,iy, fMaxIndex, index, fNpx, fNpy);
- return fMaxIndex-1;
- } else {
- return index;
- }
-}
-
-
-void AliRICHHitMapA1::FillHits()
-{
- Int_t ndigits = fDigits->GetEntriesFast();
- //printf("\n Filling hits into HitMap\n");
- //printf("FindRawClusters -- ndigits %d \n",ndigits);
- if (!ndigits) return;
- AliRICHDigit *dig;
- for (Int_t ndig=0; ndig<fNdigits; ndig++) {
- dig = (AliRICHDigit*)fDigits->UncheckedAt(ndig);
- SetHit(dig->fPadX,dig->fPadY,ndig);
- }
-}
-
-
-void AliRICHHitMapA1::SetHit(Int_t ix, Int_t iy, Int_t idigit)
-{
-// fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=idigit+1;
- fHitMap[CheckedIndex(ix, iy)]=idigit+1;
-}
-
-void AliRICHHitMapA1::DeleteHit(Int_t ix, Int_t iy)
-{
-// fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=0;
- fHitMap[CheckedIndex(ix, iy)]=0;
-}
-
-void AliRICHHitMapA1::FlagHit(Int_t ix, Int_t iy)
-{
- fHitMap[CheckedIndex(ix, iy)]=
- -TMath::Abs(fHitMap[CheckedIndex(ix, iy)]);
-}
-
-Int_t AliRICHHitMapA1::GetHitIndex(Int_t ix, Int_t iy)
-{
- return TMath::Abs(fHitMap[CheckedIndex(ix, iy)])-1;
-}
-
-TObject* AliRICHHitMapA1::GetHit(Int_t ix, Int_t iy)
-{
- Int_t index=GetHitIndex(ix,iy);
- // Force crash if index does not exist ! (Manu)
- return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
-}
-
-Flag_t AliRICHHitMapA1::TestHit(Int_t ix, Int_t iy)
-{
- Int_t inf=fHitMap[CheckedIndex(ix, iy)];
- if (inf < 0) {
- return used;
- } else if (inf == 0) {
- return empty;
- } else {
- return unused;
- }
-}
-
-
-#ifndef AliRICHHitMap_H
-#define AliRICHHitMap_H
+#ifndef ALIRICHHITMAP_H
+#define ALIRICHHITMAP_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
/* $Id$ */
-#include "AliRICH.h"
-#include "TArrayI.h"
-typedef enum {empty, used, unused} Flag_t;
+#include <TObject.h>
+
+
+typedef enum {kEmpty, kUsed, kUnused} FlagType;
const Int_t kMaxNpadx=1200, kMaxNpady=1200;
class AliRICHHitMap :
public TObject {
public:
- virtual void FillHits() =0;
- virtual void Clear() =0;
- virtual void SetHit(Int_t ix, Int_t iy, Int_t idigit) =0;
- virtual void DeleteHit(Int_t ix, Int_t iy) =0;
- virtual Int_t GetHitIndex(Int_t ix, Int_t iy) =0;
- virtual TObject * GetHit(Int_t ix, Int_t iy) =0;
- virtual void FlagHit(Int_t ix, Int_t iy) =0;
- virtual Flag_t TestHit(Int_t ix, Int_t iy) =0;
+ virtual void FillHits() =0;
+ virtual void Clear() =0;
+ virtual void SetHit(Int_t ix, Int_t iy, Int_t idigit) =0;
+ virtual void DeleteHit(Int_t ix, Int_t iy) =0;
+ virtual Int_t GetHitIndex(Int_t ix, Int_t iy) =0;
+ virtual TObject* GetHit(Int_t ix, Int_t iy) =0;
+ virtual void FlagHit(Int_t ix, Int_t iy) =0;
+ virtual FlagType TestHit(Int_t ix, Int_t iy) =0;
ClassDef(AliRICHHitMap,1) //virtual base class for muon HitMap
};
-
-class AliRICHHitMapA1 :
-public AliRICHHitMap
-{
- private:
- AliRICHSegmentation *fSegmentation;
- Int_t fNpx;
- Int_t fNpy;
- TObjArray *fDigits;
- Int_t fNdigits;
- Int_t *fHitMap; //!
- Int_t fMaxIndex;
-
- public:
- AliRICHHitMapA1(AliRICHSegmentation *seg, TObjArray *dig);
- virtual ~AliRICHHitMapA1();
- virtual void FillHits();
- virtual void Clear();
- virtual void SetHit(Int_t ix, Int_t iy, Int_t idigit);
- virtual void DeleteHit(Int_t ix, Int_t iy);
- virtual Int_t GetHitIndex(Int_t ix, Int_t iy);
- virtual TObject* GetHit(Int_t ix, Int_t);
- virtual void FlagHit(Int_t ix, Int_t iy);
- virtual Flag_t TestHit(Int_t ix, Int_t iy);
- private:
- Int_t CheckedIndex(Int_t ix, Int_t iy);
- ClassDef(AliRICHHitMapA1,1) // Implements HitMap as a 2-dim array
-};
#endif
--- /dev/null
+/**************************************************************************
+ * 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 $
+*/
+
+
+#include "AliRICHHitMapA1.h"
+#include "AliRICHSegmentation.h"
+#include "AliRICHDigit.h"
+
+#include <TObjArray.h>
+#include <TMath.h>
+
+ClassImp(AliRICHHitMapA1)
+
+
+AliRICHHitMapA1::AliRICHHitMapA1(AliRICHSegmentation *seg, TObjArray *dig)
+{
+
+// Constructor for AliRICHMapA1
+
+ fSegmentation = seg;
+ fNpx = fSegmentation->Npx();
+ fNpy = fSegmentation->Npy();
+ fMaxIndex=2*(fNpx+1)*2*(fNpy+1)+2*fNpy;
+
+ fHitMap = new Int_t[fMaxIndex];
+ fDigits = dig;
+ fNdigits = fDigits->GetEntriesFast();
+ Clear();
+}
+
+
+AliRICHHitMapA1::~AliRICHHitMapA1()
+{
+// Destructor
+// if (fDigits) delete fDigits;
+ if (fHitMap) delete[] fHitMap;
+}
+
+void AliRICHHitMapA1::Clear()
+{
+
+// Clear contents of hit map
+
+ memset(fHitMap,0,sizeof(int)*fMaxIndex);
+}
+
+Int_t AliRICHHitMapA1::CheckedIndex(Int_t ix, Int_t iy)
+{
+
+// Check if index is valid
+
+ Int_t index=2*fNpy*(ix+fNpx)+(iy+fNpy);
+ if (index > fMaxIndex) {
+ printf("\n \n \n Try to read/write outside array !!!! \n \n %d %d %d %d %d %d",ix,iy, fMaxIndex, index, fNpx, fNpy);
+ return fMaxIndex-1;
+ } else {
+ return index;
+ }
+}
+
+
+void AliRICHHitMapA1::FillHits()
+{
+
+// Fill hits into HitMap
+
+ Int_t ndigits = fDigits->GetEntriesFast();
+ //printf("\n Filling hits into HitMap\n");
+ //printf("FindRawClusters -- ndigits %d \n",ndigits);
+ if (!ndigits) return;
+ AliRICHDigit *dig;
+ for (Int_t ndig=0; ndig<fNdigits; ndig++) {
+ dig = (AliRICHDigit*)fDigits->UncheckedAt(ndig);
+ SetHit(dig->fPadX,dig->fPadY,ndig);
+ }
+}
+
+
+void AliRICHHitMapA1::SetHit(Int_t ix, Int_t iy, Int_t idigit)
+{
+//
+// Set current hit
+// fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=idigit+1;
+ fHitMap[CheckedIndex(ix, iy)]=idigit+1;
+}
+
+void AliRICHHitMapA1::DeleteHit(Int_t ix, Int_t iy)
+{
+// Delete hit
+//
+// fHitMap[kMaxNpady*(ix+fNpx)+(iy+fNpy)]=0;
+ fHitMap[CheckedIndex(ix, iy)]=0;
+}
+
+void AliRICHHitMapA1::FlagHit(Int_t ix, Int_t iy)
+{
+//
+// Flag hit
+
+ fHitMap[CheckedIndex(ix, iy)]=
+ -TMath::Abs(fHitMap[CheckedIndex(ix, iy)]);
+}
+
+Int_t AliRICHHitMapA1::GetHitIndex(Int_t ix, Int_t iy)
+{
+
+// Return hit coordinates from index
+
+ printf("ix:%d, iy:%d, index:%d\n",ix,iy,CheckedIndex(ix, iy));
+
+ return TMath::Abs(fHitMap[CheckedIndex(ix, iy)])-1;
+
+}
+
+TObject* AliRICHHitMapA1::GetHit(Int_t ix, Int_t iy)
+{
+
+// Return index from coordinates
+
+ Int_t index=GetHitIndex(ix,iy);
+ // Force crash if index does not exist ! (Manu)
+ return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
+}
+
+FlagType AliRICHHitMapA1::TestHit(Int_t ix, Int_t iy)
+{
+
+// Is there a hit?
+
+ Int_t inf=fHitMap[CheckedIndex(ix, iy)];
+ if (inf < 0) {
+ return kUsed;
+ } else if (inf == 0) {
+ return kEmpty;
+ } else {
+ return kUnused;
+ }
+}
+
+
--- /dev/null
+#ifndef ALIRICHHITMAPA1_H
+#define ALIRICHHITMAPA1_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+#include "AliRICHHitMap.h"
+
+class TObjArray;
+class AliRICHSegmentation;
+
+
+class AliRICHHitMapA1 :
+public AliRICHHitMap
+{
+
+ public:
+ AliRICHHitMapA1(AliRICHSegmentation *seg, TObjArray *dig);
+ virtual ~AliRICHHitMapA1();
+ virtual void FillHits();
+ virtual void Clear();
+ virtual void SetHit(Int_t ix, Int_t iy, Int_t idigit);
+ virtual void DeleteHit(Int_t ix, Int_t iy);
+ virtual Int_t GetHitIndex(Int_t ix, Int_t iy);
+ virtual TObject* GetHit(Int_t ix, Int_t iy);
+ virtual void FlagHit(Int_t ix, Int_t iy);
+ virtual FlagType TestHit(Int_t ix, Int_t iy);
+ private:
+ Int_t CheckedIndex(Int_t ix, Int_t iy);
+
+ private:
+ AliRICHSegmentation *fSegmentation; //Segmentation model
+ Int_t fNpx; //Pads in x
+ Int_t fNpy; //Pads in y
+ TObjArray *fDigits; //List of digits
+ Int_t fNdigits; //Number of digits
+ Int_t *fHitMap; // !
+ Int_t fMaxIndex; //Index size
+
+ ClassDef(AliRICHHitMapA1,1) // Implements HitMap as a 2-dim array
+};
+#endif
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHPadHit.h"
+
+ClassImp(AliRICHPadHit)
+//______________________________________________________________
+AliRICHPadHit::AliRICHPadHit(Int_t *clhits)
+{
+
+// Default constructor for AliRICHPadHits
+
+ fHitNumber=clhits[0];
+ fCathode=clhits[1];
+ fQ=clhits[2];
+ fPadX=clhits[3];
+ fPadY=clhits[4];
+ fQpad=clhits[5];
+ fRSec=clhits[6];
+}
+
--- /dev/null
+#ifndef ALIRICHPADHIT_H
+#define ALIRICHPADHIT_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include <TObject.h>
+
+class AliRICHPadHit : public TObject {
+ public:
+
+ Int_t fHitNumber; // Hit number
+ Int_t fCathode; // Cathode number
+ Int_t fQ ; // Total charge
+ Int_t fPadX ; // Pad number along X
+ Int_t fPadY ; // Pad number along Y
+ Int_t fQpad ; // Charge per pad
+ Int_t fRSec ; // R -sector of pad
+
+ public:
+ AliRICHPadHit() {
+ fHitNumber=fQ=fPadX=fPadY=fQpad=fRSec=0;
+ }
+ AliRICHPadHit(Int_t *clhits);
+ virtual ~AliRICHPadHit() {}
+
+ ClassDef(AliRICHPadHit,1) //Cluster object for set:RICH
+};
+#endif
/*
$Log$
+ Revision 1.1 2000/06/09 14:53:01 jbarbosa
+ Bari's pattern recognition algorithm
+
*/
-#include "DataStructures.h"
+#include "AliRICHHit.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHPadHit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit.h"
#include "AliRun.h"
#include "AliDetector.h"
#include "AliRICH.h"
#include "AliRICHPoints.h"
-#include "AliRICHSegResV0.h"
+#include "AliRICHSegmentation.h"
#include "AliRICHPatRec.h"
#include "AliRICH.h"
#include "AliRICHConst.h"
#include "AliRICHPoints.h"
#include "AliConst.h"
-#include "TParticle.h"
-#include "TMath.h"
-#include "TRandom.h"
-#include "TCanvas.h"
-#include "TH2.h"
+
+#include <TParticle.h>
+#include <TMath.h>
+#include <TRandom.h>
+#include <TCanvas.h>
+#include <TH2.h>
ClassImp(AliRICHPatRec)
//___________________________________________
AliRICHPatRec::AliRICHPatRec() : TObject()
{
+ // Default constructor
+
//fChambers = 0;
}
//___________________________________________
AliRICHPatRec::AliRICHPatRec(const char *name, const char *title)
: TObject()
{
-
+ //Constructor for Bari's pattern recogniton method object
}
void AliRICHPatRec::PatRec()
{
+// Pattern recognition algorithm
+
AliRICHChamber* iChamber;
AliRICHSegmentation* segmentation;
- Int_t ntracks, ndigits[7];
+ Int_t ntracks, ndigits[kNCH];
Int_t itr, ich, i;
- Int_t GoodPhotons;
+ Int_t goodPhotons;
Int_t x,y,q;
Float_t rx,ry;
Int_t nent,status;
- Float_t gamma,MassCer,BetaCer;
+ Float_t gamma,massCer,betaCer;
Float_t rechit[5];
TH1F *hough = new TH1F("hough","hough",75,0.45,0.75);
TH1F *mass = new TH1F("mass","mass",100,50.,1050.);
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
- TTree *TH = gAlice->TreeH();
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
+ TTree *treeH = gAlice->TreeH();
- ntracks =(Int_t) TH->GetEntries();
+ ntracks =(Int_t) treeH->GetEntries();
// ntracks = 1;
for (itr=0; itr<ntracks; itr++) {
printf(" theta %f phi %f track \n",fTrackTheta,fTrackPhi);
// ring->Fill(fTrackLoc[0],fTrackLoc[1],100.);
- iChamber = &(RICH->Chamber(ich));
+ iChamber = &(pRICH->Chamber(ich));
segmentation=iChamber->GetSegmentationModel();
nent=(Int_t)gAlice->TreeD()->GetEntries();
gAlice->TreeD()->GetEvent(nent-1);
- TClonesArray *Digits = RICH->DigitsAddress(ich);
- ndigits[ich] = Digits->GetEntriesFast();
+ TClonesArray *pDigitss = pRICH->DigitsAddress(ich);
+ ndigits[ich] = pDigitss->GetEntriesFast();
printf("ndigits %d in chamber %d\n",ndigits[ich],ich);
AliRICHDigit *padI = 0;
- GoodPhotons = 0;
+ goodPhotons = 0;
for (Int_t dig=0;dig<ndigits[ich];dig++) {
- padI=(AliRICHDigit*) Digits->UncheckedAt(dig);
+ padI=(AliRICHDigit*) pDigitss->UncheckedAt(dig);
x=padI->fPadX;
y=padI->fPadY;
q=padI->fSignal;
ring->Fill(fXpad,fYpad,1.);
cerangle->Fill(fCerenkovAnglePad,1.);
- GoodPhotons++;
- fEtaPhotons[GoodPhotons] = fCerenkovAnglePad;
+ goodPhotons++;
+ fEtaPhotons[goodPhotons] = fCerenkovAnglePad;
}
- fNumEtaPhotons = GoodPhotons;
+ fNumEtaPhotons = goodPhotons;
BackgroundEstimation();
- for(i=0;i<GoodPhotons;i++) {
+ for(i=0;i<goodPhotons;i++) {
ceranglew->Fill(fEtaPhotons[i],fWeightPhotons[i]);
// printf(" Eta %f weight %f \n",fEtaPhotons[i],fWeightPhotons[i]);
}
hough->Fill(fThetaCerenkov,1.);
- RICH->AddRecHit(ich,rechit);
+ pRICH->AddRecHit(ich,rechit);
- BetaCer = BetaCerenkov(1.29,fThetaCerenkov);
- gamma = 1./sqrt(1.-pow(BetaCer,2));
- MassCer = fTrackMom/(BetaCer*gamma);
- // printf(" mass %f \n",MassCer);
- mass->Fill(MassCer*1000,1.);
+ betaCer = BetaCerenkov(1.29,fThetaCerenkov);
+ gamma = 1./sqrt(1.-pow(betaCer,2));
+ massCer = fTrackMom/(betaCer*gamma);
+ // printf(" mass %f \n",massCer);
+ mass->Fill(massCer*1000,1.);
}
gAlice->TreeR()->Fill();
TClonesArray *fRec;
- for (i=0;i<7;i++) {
- fRec=RICH->RecHitsAddress(i);
+ for (i=0;i<kNCH;i++) {
+ fRec=pRICH->RecHitsAddress(i);
int ndig=fRec->GetEntriesFast();
printf ("Chamber %d, rings %d\n",i,ndig);
}
- RICH->ResetRecHits();
+ pRICH->ResetRecHits();
c1->Divide(2,2);
printf("Calling TrackParam\n");
gAlice->ResetHits();
- TTree *TH = gAlice->TreeH();
- TH->GetEvent(itr);
+ TTree *treeH = gAlice->TreeH();
+ treeH->GetEvent(itr);
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
- AliRICHHit* mHit=(AliRICHHit*)RICH->FirstHit(-1);
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICHHit* mHit=(AliRICHHit*)pRICH->FirstHit(-1);
if(mHit==0) return 1;
ich = mHit->fChamber-1;
trackglob[0] = mHit->fX;
iloss = mHit->fLoss;
part = mHit->fParticle;
- iChamber = &(RICH->Chamber(ich));
+ iChamber = &(pRICH->Chamber(ich));
iChamber->GlobaltoLocal(trackglob,trackloc);
segmentation=iChamber->GetSegmentationModel();
Float_t AliRICHPatRec::EstimationAtLimits(Float_t lim, Float_t radius,
Float_t phiphot)
{
+
+// Estimation of emission point
+
Float_t nquartz = 1.585;
Float_t ngas = 1.;
Float_t nfreon = 1.295;
Float_t eps = 0.0001;
Int_t niterEmiss = 0;
Int_t niterEmissMax = 0;
- Float_t x1,x2,x3,p1,p2,p3;
+ Float_t x1,x2,x3=0,p1,p2,p3;
Float_t argY,argX;
Int_t niterFun;
void AliRICHPatRec::EmissionPoint()
{
- Float_t AbsorLength=7.83*fRw; //absorption length in the freon (cm)
+
+// Find emission point
+
+ Float_t absorbtionLength=7.83*fRw; //absorption length in the freon (cm)
// 7.83 = -1/ln(T0) where
// T0->Trasmission freon at 180nm = 0.88 (Eph=6.85eV)
- Float_t PhotonLength, PhotonLengthMin, PhotonLengthMax;
+ Float_t photonLength, photonLengthMin, photonLengthMax;
- PhotonLength=exp(-fRw/(AbsorLength*cos(fCerenkovAnglePad)));
- PhotonLengthMin=fRw*PhotonLength/(1.-PhotonLength);
- PhotonLengthMax=AbsorLength*cos(fCerenkovAnglePad);
- fEmissPoint = fRw + PhotonLengthMin - PhotonLengthMax;
+ photonLength=exp(-fRw/(absorbtionLength*cos(fCerenkovAnglePad)));
+ photonLengthMin=fRw*photonLength/(1.-photonLength);
+ photonLengthMax=absorbtionLength*cos(fCerenkovAnglePad);
+ fEmissPoint = fRw + photonLengthMin - photonLengthMax;
}
void AliRICHPatRec::PhotonSelection(Int_t track, Int_t &nphot, Float_t &thetamean)
{
+
+// not implemented yet
+
printf("Calling PhotonSelection\n");
}
void AliRICHPatRec::BackgroundEstimation()
{
- Float_t StepEta = 0.001;
- Float_t EtaMinBkg = 0.72;
- Float_t EtaMaxBkg = 0.75;
- Float_t EtaMin = 0.;
- Float_t EtaMax = 0.75;
+
+// estimate background noise
+
+ Float_t stepEta = 0.001;
+ Float_t etaMinBkg = 0.72;
+ Float_t etaMaxBkg = 0.75;
+ Float_t etaMin = 0.;
+ Float_t etaMax = 0.75;
Float_t ngas = 1.;
Float_t nfreon = 1.295;
- Float_t EtaStepMin,EtaStepMax,EtaStepAvg;
+ Float_t etaStepMin,etaStepMax,etaStepAvg;
Int_t i,ip,nstep;
- Int_t NumPhotBkg, NumPhotonStep;
- Float_t FunBkg,AreaBkg,NormBkg;
- Float_t DensityBkg,StoreBkg,NumStore;
- Float_t ThetaSig;
+ Int_t numPhotBkg, numPhotonStep;
+ Float_t funBkg,areaBkg,normBkg;
+ Float_t densityBkg,storeBkg,numStore;
+ Float_t thetaSig;
- NumPhotBkg = 0;
- AreaBkg = 0.;
+ numPhotBkg = 0;
+ areaBkg = 0.;
- nstep = (int)((EtaMaxBkg-EtaMinBkg)/StepEta);
+ nstep = (int)((etaMaxBkg-etaMinBkg)/stepEta);
for (i=0;i<fNumEtaPhotons;i++) {
- if(fEtaPhotons[i]>EtaMinBkg && fEtaPhotons[i]<EtaMaxBkg) {
- NumPhotBkg++;
+ if(fEtaPhotons[i]>etaMinBkg && fEtaPhotons[i]<etaMaxBkg) {
+ numPhotBkg++;
}
}
- if (NumPhotBkg == 0) {
+ if (numPhotBkg == 0) {
for (i=0;i<fNumEtaPhotons;i++) {
fWeightPhotons[i] = 1.;
}
return;
}
- // printf(" NumPhotBkg %i ",NumPhotBkg);
+ // printf(" numPhotBkg %i ",numPhotBkg);
for (i=0;i<nstep;i++) {
- EtaStepMin = EtaMinBkg + (Float_t)(i)*StepEta;
- EtaStepMax = EtaMinBkg + (Float_t)(i+1)*StepEta;
- EtaStepAvg = 0.5*(EtaStepMax + EtaStepMin);
+ etaStepMin = etaMinBkg + (Float_t)(i)*stepEta;
+ etaStepMax = etaMinBkg + (Float_t)(i+1)*stepEta;
+ etaStepAvg = 0.5*(etaStepMax + etaStepMin);
/*
- FunBkg = tan(EtaStepAvg)*pow((1.+pow(tan(EtaStepAvg),2)),
- 5.52)-7.803 + 22.02*tan(EtaStepAvg);
+ funBkg = tan(etaStepAvg)*pow((1.+pow(tan(etaStepAvg),2)),
+ 5.52)-7.803 + 22.02*tan(etaStepAvg);
*/
- ThetaSig = asin(nfreon/ngas*sin(EtaStepAvg));
- FunBkg = tan(ThetaSig)*(1.+pow(tan(ThetaSig),2))*nfreon
- /ngas*cos(EtaStepAvg)/cos(ThetaSig);
- AreaBkg += StepEta*FunBkg;
+ thetaSig = asin(nfreon/ngas*sin(etaStepAvg));
+ funBkg = tan(thetaSig)*(1.+pow(tan(thetaSig),2))*nfreon
+ /ngas*cos(etaStepAvg)/cos(thetaSig);
+ areaBkg += stepEta*funBkg;
}
- DensityBkg = 0.95*(Float_t)(NumPhotBkg)/AreaBkg;
- // printf(" DensityBkg %f \n",DensityBkg);
+ densityBkg = 0.95*(Float_t)(numPhotBkg)/areaBkg;
+ // printf(" densityBkg %f \n",densityBkg);
- nstep = (int)((EtaMax-EtaMin)/StepEta);
- StoreBkg = 0.;
- NumStore = 0;
+ nstep = (int)((etaMax-etaMin)/stepEta);
+ storeBkg = 0.;
+ numStore = 0;
for (i=0;i<nstep;i++) {
- EtaStepMin = EtaMinBkg + (Float_t)(i)*StepEta;
- EtaStepMax = EtaMinBkg + (Float_t)(i+1)*StepEta;
- EtaStepAvg = 0.5*(EtaStepMax + EtaStepMin);
+ etaStepMin = etaMinBkg + (Float_t)(i)*stepEta;
+ etaStepMax = etaMinBkg + (Float_t)(i+1)*stepEta;
+ etaStepAvg = 0.5*(etaStepMax + etaStepMin);
/*
- FunBkg = tan(EtaStepAvg)*pow((1.+pow(tan(EtaStepAvg),2)),
- 5.52)-7.803 + 22.02*tan(EtaStepAvg);
+ funBkg = tan(etaStepAvg)*pow((1.+pow(tan(etaStepAvg),2)),
+ 5.52)-7.803 + 22.02*tan(etaStepAvg);
*/
- ThetaSig = asin(nfreon/ngas*sin(EtaStepAvg));
- FunBkg = tan(ThetaSig)*(1.+pow(tan(ThetaSig),2))*nfreon
- /ngas*cos(EtaStepAvg)/cos(ThetaSig);
+ thetaSig = asin(nfreon/ngas*sin(etaStepAvg));
+ funBkg = tan(thetaSig)*(1.+pow(tan(thetaSig),2))*nfreon
+ /ngas*cos(etaStepAvg)/cos(thetaSig);
- AreaBkg = StepEta*FunBkg;
- NormBkg = DensityBkg*AreaBkg;
- NumPhotonStep = 0;
+ areaBkg = stepEta*funBkg;
+ normBkg = densityBkg*areaBkg;
+ numPhotonStep = 0;
for (ip=0;ip<fNumEtaPhotons;ip++) {
- if(fEtaPhotons[ip]>EtaStepMin && fEtaPhotons[ip]<EtaStepMax) {
- NumPhotonStep++;
+ if(fEtaPhotons[ip]>etaStepMin && fEtaPhotons[ip]<etaStepMax) {
+ numPhotonStep++;
}
}
- if (NumPhotonStep == 0) {
- StoreBkg += NormBkg;
- NumStore++;
- if (NumStore>50) {
- NumStore = 0;
- StoreBkg = 0.;
+ if (numPhotonStep == 0) {
+ storeBkg += normBkg;
+ numStore++;
+ if (numStore>50) {
+ numStore = 0;
+ storeBkg = 0.;
}
}
- if (NumPhotonStep == 0) continue;
+ if (numPhotonStep == 0) continue;
for (ip=0;ip<fNumEtaPhotons;ip++) {
- if(fEtaPhotons[ip]>EtaStepMin && fEtaPhotons[ip]<EtaStepMax) {
- NormBkg +=StoreBkg;
- StoreBkg = 0;
- NumStore = 0;
- fWeightPhotons[ip] = 1. - NormBkg/(Float_t)(NumPhotonStep);
+ if(fEtaPhotons[ip]>etaStepMin && fEtaPhotons[ip]<etaStepMax) {
+ normBkg +=storeBkg;
+ storeBkg = 0;
+ numStore = 0;
+ fWeightPhotons[ip] = 1. - normBkg/(Float_t)(numPhotonStep);
/*
- printf(" NormBkg %f NumPhotonStep %i fW %f \n",
- NormBkg, NumPhotonStep, fWeightPhotons[ip]);
+ printf(" normBkg %f numPhotonStep %i fW %f \n",
+ normBkg, numPhotonStep, fWeightPhotons[ip]);
*/
if(fWeightPhotons[ip]<0) fWeightPhotons[ip] = 0.;
}
void AliRICHPatRec::FlagPhotons(Int_t track, Float_t theta)
{
+
+// not implemented yet
+
printf("Calling FlagPhotons\n");
}
//0=label for parameters giving internal band ellipse
//1=label for parameters giving external band ellipse
- Float_t imp[2], mass[2], Energ[2], beta[2];
- Float_t EmissPointLength[2];
- Float_t E1, E2, F1, F2;
+ Float_t imp[2], mass[2], energy[2], beta[2];
+ Float_t emissPointLength[2];
+ Float_t e1, e2, f1, f2;
Float_t nfreon[2], nquartz[2];
Int_t times;
mass[0] = 0.938; //proton mass
mass[1] = 0.139; //pion mass
- EmissPointLength[0] = fRw-0.0001; //at the beginning of the radiator
- EmissPointLength[1] = 0.;//at the end of radiator
+ emissPointLength[0] = fRw-0.0001; //at the beginning of the radiator
+ emissPointLength[1] = 0.;//at the end of radiator
//parameters to calculate freon window refractive index vs. energy
Float_t a = 1.177;
Energ[0] = 5.6;
Energ[1] = 7.7;
*/
- Energ[0] = 5.0;
- Energ[1] = 8.0;
- E1 = 10.666;
- E2 = 18.125;
- F1 = 46.411;
- F2 = 228.71;
+ energy[0] = 5.0;
+ energy[1] = 8.0;
+ e1 = 10.666;
+ e2 = 18.125;
+ f1 = 46.411;
+ f2 = 228.71;
phpad = PhiPad();
for (times=0; times<=1; times++) {
- nfreon[times] = a+b*Energ[times];
+ nfreon[times] = a+b*energy[times];
- nquartz[times] = sqrt(1+(F1/(pow(E1,2)-pow(Energ[times],2)))+
- (F2/(pow(E2,2)-pow(Energ[times],2))));
+ nquartz[times] = sqrt(1+(f1/(pow(e1,2)-pow(energy[times],2)))+
+ (f2/(pow(e2,2)-pow(energy[times],2))));
beta[times] = imp[times]/sqrt(pow(imp[times],2)+pow(mass[times],2));
thetacer[times] = CherenkovAngle( nfreon[times], beta[times]);
bandradius[times] = DistanceFromMip( nfreon[times], nquartz[times],
- EmissPointLength[times],
+ emissPointLength[times],
thetacer[times], phpad);
}
}
Float_t AliRICHPatRec::DistanceFromMip(Float_t nfreon, Float_t nquartz,
- Float_t EmissPointLength, Float_t thetacer,
+ Float_t emissPointLength, Float_t thetacer,
Float_t phpad)
{
- Float_t DistanceValue;
- TVector3 RadExitPhot(1,1,1);//photon impact at the radiator exit with respect
+// Find the distance to MIP impact
+
+ Float_t distanceValue;
+
+ TVector3 radExitPhot(1,1,1);//photon impact at the radiator exit with respect
//to local reference sistem with the origin in the MIP entrance
- TVector3 VectEmissPointLength(1,1,1);
- Float_t MagEmissPointLenght;
+ TVector3 vectEmissPointLength(1,1,1);
+ Float_t magEmissPointLenght;
- TVector3 RadExitPhot2(1,1,1);//photon impact at the radiator exit with respect
- Float_t MagRadExitPhot2;
+ TVector3 radExitPhot2(1,1,1);//photon impact at the radiator exit with respect
+ Float_t magRadExitPhot2;
//to a reference sistem with origin in the photon emission point and
//axes parallel to the MIP reference sistem
- TVector3 QuarExitPhot(1,1,1);//photon impact at the quartz exit with respect
- Float_t MagQuarExitPhot;
+ TVector3 quarExitPhot(1,1,1);//photon impact at the quartz exit with respect
+ Float_t magQuarExitPhot;
//
- TVector3 GapExitPhot(1,1,1) ;
- Float_t MagGapExitPhot;
+ TVector3 gapExitPhot(1,1,1) ;
+ Float_t magGapExitPhot;
//
TVector3 fPhotocatExitPhot(1,1,1);
Double_t theta2;
Float_t ngas = 1.;
- MagEmissPointLenght = EmissPointLength/cos(fTrackTheta);
+ magEmissPointLenght = emissPointLength/cos(fTrackTheta);
- VectEmissPointLength.SetMag(MagEmissPointLenght);
- VectEmissPointLength.SetTheta(fTrackTheta);
- VectEmissPointLength.SetPhi(fTrackPhi);
+ vectEmissPointLength.SetMag(magEmissPointLenght);
+ vectEmissPointLength.SetTheta(fTrackTheta);
+ vectEmissPointLength.SetPhi(fTrackPhi);
- RadExitPhot2.SetTheta(thetacer);
- RadExitPhot2.SetPhi(phpad);
+ radExitPhot2.SetTheta(thetacer);
+ radExitPhot2.SetPhi(phpad);
TRotation r1;
//following by a rotation about the z axis by MIP phi incidence angle;
- RadExitPhot2 = r * RadExitPhot2;
- theta2 = RadExitPhot2.Theta();
- MagRadExitPhot2 = (fRw - VectEmissPointLength(2))/cos(theta2);
- RadExitPhot2.SetMag(MagRadExitPhot2);
+ radExitPhot2 = r * radExitPhot2;
+ theta2 = radExitPhot2.Theta();
+ magRadExitPhot2 = (fRw - vectEmissPointLength(2))/cos(theta2);
+ radExitPhot2.SetMag(magRadExitPhot2);
- RadExitPhot = VectEmissPointLength + RadExitPhot2;
- thetarad = RadExitPhot.Theta();
+ radExitPhot = vectEmissPointLength + radExitPhot2;
+ thetarad = radExitPhot.Theta();
- phirad = RadExitPhot.Phi(); //check on the original file //
+ phirad = radExitPhot.Phi(); //check on the original file //
thetaquar = SnellAngle( nfreon, nquartz, theta2);
- phiquar = RadExitPhot2.Phi();
+ phiquar = radExitPhot2.Phi();
if(thetaquar == 999.) return thetaquar;
- MagQuarExitPhot = fQw/cos(thetaquar);
- QuarExitPhot.SetMag( MagQuarExitPhot);
- QuarExitPhot.SetTheta(thetaquar);
- QuarExitPhot.SetPhi(phiquar);
+ magQuarExitPhot = fQw/cos(thetaquar);
+ quarExitPhot.SetMag( magQuarExitPhot);
+ quarExitPhot.SetTheta(thetaquar);
+ quarExitPhot.SetPhi(phiquar);
thetagap = SnellAngle( nquartz, ngas, thetaquar);
phigap = phiquar;
if(thetagap == 999.) return thetagap;
- MagGapExitPhot = fTgap/cos(thetagap);
- GapExitPhot.SetMag( MagGapExitPhot);
- GapExitPhot.SetTheta(thetagap);
- GapExitPhot.SetPhi(phigap);
+ magGapExitPhot = fTgap/cos(thetagap);
+ gapExitPhot.SetMag( magGapExitPhot);
+ gapExitPhot.SetTheta(thetagap);
+ gapExitPhot.SetPhi(phigap);
- fPhotocatExitPhot = RadExitPhot + QuarExitPhot + GapExitPhot;
+ fPhotocatExitPhot = radExitPhot + quarExitPhot + gapExitPhot;
- DistanceValue = sqrt(pow(fPhotocatExitPhot(0),2)
+ distanceValue = sqrt(pow(fPhotocatExitPhot(0),2)
+pow(fPhotocatExitPhot(1),2));
- return DistanceValue ;
+ return distanceValue ;
}
Float_t AliRICHPatRec::PhiPad()
{
+
+// ??
+
Float_t zpad;
Float_t thetapad, phipad;
Float_t thetarot, phirot;
zpad = fRw + fQw + fTgap;
- TVector3 PhotonPad(fXpad, fYpad, zpad);
- thetapad = PhotonPad.Theta();
- phipad = PhotonPad.Phi();
+ TVector3 photonPad(fXpad, fYpad, zpad);
+ thetapad = photonPad.Theta();
+ phipad = photonPad.Phi();
TRotation r1;
TRotation r2;
r = r2 * r1;//rotation about the z axis by MIP -phi incidence angle
//following by a rotation about the y axis by MIP -theta incidence angle;
- PhotonPad = r * PhotonPad;
+ photonPad = r * photonPad;
- phipad = PhotonPad.Phi();
+ phipad = photonPad.Phi();
return phipad;
}
Float_t AliRICHPatRec:: SnellAngle(Float_t n1, Float_t n2, Float_t theta1)
{
+
+// Compute the Snell angle
+
Float_t sinrefractangle;
Float_t refractangle;
Float_t AliRICHPatRec::CherenkovAngle(Float_t n, Float_t beta)
{
+
+// Compute the cerenkov angle
+
Float_t thetacer;
if((n*beta)<1.) {
Float_t AliRICHPatRec::BetaCerenkov(Float_t n, Float_t theta)
{
+
+// Find beta
+
Float_t beta;
beta = 1./(n*cos(theta));
void AliRICHPatRec::HoughResponse()
{
+
+// Implement Hough response pat. rec. method
+
int bin=0;
int bin1=0;
int bin2=0;
- int i, j, k, NcorrBand;
- int EtaBin = 750;
- float HCS[750];
- float angle, ThetaCerMean;
+ int i, j, k, nCorrBand;
+ int etaBin = 750;
+ float hcs[750];
+ float angle, thetaCerMean;
- float EtaPeak[30];
- float EtaMin = 0.00;
- float EtaMax = 0.75;
- float StepEta = 0.001;
- float WindowEta = 0.040;
+ float etaPeak[30];
+ float etaMin = 0.00;
+ float etaMax = 0.75;
+ float stepEta = 0.001;
+ float windowEta = 0.040;
- int Nbin;
+ int nBin;
- float EtaPeakPos = -1;
- Int_t EtaPeakCount = -1;
+ float etaPeakPos = -1;
+ Int_t etaPeakCount = -1;
- ThetaCerMean = 0.;
+ thetaCerMean = 0.;
fThetaCerenkov = 0.;
- Nbin = (int)(0.5+EtaMax/(StepEta));
- NcorrBand = (int)(0.5+ WindowEta/(2 * StepEta));
- memset ((void *)HCS, 0, EtaBin*sizeof(int));
+ nBin = (int)(0.5+etaMax/(stepEta));
+ nCorrBand = (int)(0.5+ windowEta/(2 * stepEta));
+ memset ((void *)hcs, 0, etaBin*sizeof(int));
for (k=0; k< fNumEtaPhotons; k++) {
angle = fEtaPhotons[k];
- if (angle>=EtaMin && angle<= EtaMax) {
- bin = (int)(0.5+angle/(StepEta));
- bin1= bin-NcorrBand;
- bin2= bin+NcorrBand;
+ if (angle>=etaMin && angle<= etaMax) {
+ bin = (int)(0.5+angle/(stepEta));
+ bin1= bin-nCorrBand;
+ bin2= bin+nCorrBand;
if (bin1<0) bin1=0;
- if (bin2>Nbin) bin2=Nbin;
+ if (bin2>nBin) bin2=nBin;
for (j=bin1; j<bin2; j++) {
- HCS[j] += fWeightPhotons[k];
+ hcs[j] += fWeightPhotons[k];
}
- ThetaCerMean += angle;
+ thetaCerMean += angle;
}
}
- ThetaCerMean /= fNumEtaPhotons;
+ thetaCerMean /= fNumEtaPhotons;
- HoughFiltering(HCS);
-
- for (bin=0; bin <Nbin; bin++) {
- angle = (bin+0.5) * (StepEta);
- if (HCS[bin] && HCS[bin] > EtaPeakPos) {
- EtaPeakCount = 0;
- EtaPeakPos = HCS[bin];
- EtaPeak[0]=angle;
+ HoughFiltering(hcs);
+
+ for (bin=0; bin <nBin; bin++) {
+ angle = (bin+0.5) * (stepEta);
+ if (hcs[bin] && hcs[bin] > etaPeakPos) {
+ etaPeakCount = 0;
+ etaPeakPos = hcs[bin];
+ etaPeak[0]=angle;
}
else {
- if (HCS[bin] == EtaPeakPos) {
- EtaPeak[++EtaPeakCount] = angle;
+ if (hcs[bin] == etaPeakPos) {
+ etaPeak[++etaPeakCount] = angle;
}
}
}
- for (i=0; i<EtaPeakCount+1; i++) {
- fThetaCerenkov += EtaPeak[i];
+ for (i=0; i<etaPeakCount+1; i++) {
+ fThetaCerenkov += etaPeak[i];
}
- if (EtaPeakCount>=0) {
- fThetaCerenkov /= EtaPeakCount+1;
- fThetaPeakPos = EtaPeakPos;
+ if (etaPeakCount>=0) {
+ fThetaCerenkov /= etaPeakCount+1;
+ fThetaPeakPos = etaPeakPos;
}
}
-void AliRICHPatRec::HoughFiltering(float HCS[])
+void AliRICHPatRec::HoughFiltering(float hcs[])
{
- float HCS_filt[750];
- float K[5] = {0.05, 0.25, 0.4, 0.25, 0.05};
- int nx, i, nx_dx;
+
+// hough filtering
+
+ float hcsFilt[750];
+ float k[5] = {0.05, 0.25, 0.4, 0.25, 0.05};
+ int nx, i, nxDx;
int sizeHCS;
- int Nbin;
+ int nBin;
- int EtaBin = 750;
- float EtaMax = 0.75;
- float StepEta = 0.001;
+ int etaBin = 750;
+ float etaMax = 0.75;
+ float stepEta = 0.001;
- Nbin = (int)(1+EtaMax/StepEta);
- sizeHCS = EtaBin*sizeof(float);
+ nBin = (int)(1+etaMax/stepEta);
+ sizeHCS = etaBin*sizeof(float);
- memset ((void *)HCS_filt, 0, sizeHCS);
+ memset ((void *)hcsFilt, 0, sizeHCS);
- for (nx = 0; nx < Nbin; nx++) {
+ for (nx = 0; nx < nBin; nx++) {
for (i = 0; i < 5; i++) {
- nx_dx = nx + (i-2);
- if (nx_dx> -1 && nx_dx<Nbin)
- HCS_filt[nx] += HCS[nx_dx] * K[i];
+ nxDx = nx + (i-2);
+ if (nxDx> -1 && nxDx<nBin)
+ hcsFilt[nx] += hcs[nxDx] * k[i];
}
}
- for (nx = 0; nx < Nbin; nx++) {
- HCS[nx] = HCS_filt[nx];
+ for (nx = 0; nx < nBin; nx++) {
+ hcs[nx] = hcsFilt[nx];
}
}
Float_t AliRICHPatRec::CherenkovRingDrawing(Float_t fixedthetacer)
-
{
//to draw Cherenkov ring by known Cherenkov angle
- Int_t nmaxdegrees, nstepdegrees;
- Float_t phpad, thetacer;
- Float_t nfreonave, nquartzave;
- Float_t AveEnerg;
- Float_t Energ[2];
- Float_t E1, E2, F1, F2;
- Float_t bandradius;
- Float_t CoordPadRing;
-
+ Int_t nmaxdegrees, nstepdegrees;
+ Float_t phpad, thetacer;
+ Float_t nfreonave, nquartzave;
+ Float_t aveEnerg;
+ Float_t energy[2];
+ Float_t e1, e2, f1, f2;
+ Float_t bandradius;
+ Float_t coordPadRing;
+
//parameters to calculate freon window refractive index vs. energy
- Float_t a = 1.177;
- Float_t b = 0.0172;
-
+ Float_t a = 1.177;
+ Float_t b = 0.0172;
+
//parameters to calculate quartz window refractive index vs. energy
/*
Energ[0] = 5.6;
Energ[1] = 7.7;
*/
- Energ[0] = 5.0;
- Energ[1] = 8.0;
- E1 = 10.666;
- E2 = 18.125;
- F1 = 46.411;
- F2 = 228.71;
-
-
- nmaxdegrees = 360;
+ energy[0] = 5.0;
+ energy[1] = 8.0;
+ e1 = 10.666;
+ e2 = 18.125;
+ f1 = 46.411;
+ f2 = 228.71;
+
+ nmaxdegrees = 360;
+
nstepdegrees = 36;
-
+
for (phpad=0; phpad<nmaxdegrees;phpad++) {
- AveEnerg = (Energ[0]+Energ[1])/2.;
-
- nfreonave = a+b*AveEnerg;
- nquartzave = sqrt(1+(F1/(pow(E1,2)-pow(AveEnerg,2)))+
- (F2/(pow(E2,2)-pow(AveEnerg,2))));
-
- thetacer = fixedthetacer;
-
- bandradius = DistanceFromMip(nfreonave, nquartzave,
+ aveEnerg = (energy[0]+energy[1])/2.;
+
+ nfreonave = a+b*aveEnerg;
+ nquartzave = sqrt(1+(f1/(pow(e1,2)-pow(aveEnerg,2)))+
+ (f2/(pow(e2,2)-pow(aveEnerg,2))));
+
+ thetacer = fixedthetacer;
+
+ bandradius = DistanceFromMip(nfreonave, nquartzave,
fEmissPoint,thetacer, phpad);
- CoordPadRing=fPhotocatExitPhot;
+ coordPadRing=fPhotocatExitPhot;
+
+ phpad = (nmaxdegrees/nstepdegrees)*phpad;
+
+ return coordPadRing;
+ }
+
+ return coordPadRing;
+}
- phpad = (nmaxdegrees/nstepdegrees)*phpad;
- return CoordPadRing;
- }
- }
-#ifndef AliRICHPatRec_H
-#define AliRICHPatRec_H
+#ifndef ALIRICHPATREC_H
+#define ALIRICHPATREC_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
//new
Float_t CherenkovRingDrawing(Float_t fixedthetacer);
+ public:
+ Int_t fNumEtaPhotons; // Number of photons
+ Float_t fEtaPhotons[1000]; // Cerenkov angle each photon
+ Float_t fWeightPhotons[1000]; // weight for each photon
+ Float_t fThetaCerenkov; // Theta angle for photon
+ Float_t fThetaPeakPos; // Peak position
+
+ Float_t fDTheta; //Step for sliding window
+ Float_t fWindowWidth; //Hough width of sliding window
private:
- Float_t fRw,fQw,fTgap;
+ Float_t fRw,fQw,fTgap; //
- Float_t fTrackLoc[3];
- Float_t fTrackTheta;
- Float_t fTrackPhi;
- Float_t fTrackMom;
- Float_t fXpad;
- Float_t fYpad;
- Int_t fQpad;
+ Float_t fTrackLoc[3]; // Position of track
+ Float_t fTrackTheta; // Theta angle for track (dip angle)
+ Float_t fTrackPhi; // Phi angle
+ Float_t fTrackMom; // Track momentum
+ Float_t fXpad; // x-position of pad hit
+ Float_t fYpad; // y-position of pad hit
+ Int_t fQpad; // Charge deposited
- Float_t fXshift,fYshift;
- Float_t fEmissPoint;
+ Float_t fXshift,fYshift; // Shifts in x and y
+ Float_t fEmissPoint; // Emission point for Cerenkov photons
Float_t fCerenkovAnglePad; // Cerenkov angle of single pad
- Float_t fPhotocatExitPhot;
+ Float_t fPhotocatExitPhot; // Point of exit from photocathode
- public:
- Int_t fNumEtaPhotons;
- Float_t fEtaPhotons[1000]; // Cerenkov angle each photon
- Float_t fWeightPhotons[1000]; // weight for each photon
- Float_t fThetaCerenkov;
- Float_t fThetaPeakPos;
-
- Float_t fDTheta; //Step for sliding window
- Float_t fWindowWidth; //Hough width of sliding window
- ClassDef(AliRICHPatRec,1) //Pat Rec module for :RICH version 0
+ ClassDef(AliRICHPatRec,1) //Pat Rec module for :RICH version 0
- };
+};
/*
$Log$
+ Revision 1.2 2000/05/18 13:43:54 jbarbosa
+ Added the ShowRing function.
+
Revision 1.1 2000/04/19 13:16:47 morsch
Minor changes on class names.
// //
// //
///////////////////////////////////////////////////////////////////////////////
+#include <TPad.h>
+#include <TView.h>
+#include <TMath.h>
+
#include "AliRICHDisplay.h"
#include "AliRICHPoints.h"
#include "AliRun.h"
-#include "TPad.h"
-#include "TView.h"
-#include "TMath.h"
-
-const Int_t MAX_Nipx=400, MAX_Nipy=800;
+#include "AliRICHHit.h"
+#include "AliRICHCerenkov.h"
+#include "AliRICHPadHit.h"
+#include "AliRICHDigit.h"
+#include "AliRICHRawCluster.h"
+#include "AliRICHRecHit.h"
+
+const Int_t kMaxNipx=400, kMaxNipy=800;
ClassImp(AliRICHPoints)
//
// Returns pointer to hit index in AliRun::fParticles
//
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
gAlice->TreeH()->GetEvent(fTrackIndex);
- TClonesArray *RICHhits = RICH->Hits();
- Int_t nhits = RICHhits->GetEntriesFast();
+ TClonesArray *pRICHhits = pRICH->Hits();
+ Int_t nhits = pRICHhits->GetEntriesFast();
if (fHitIndex < 0 || fHitIndex >= nhits) return 0;
- return (AliRICHHit*)RICHhits->UncheckedAt(fHitIndex);
+ return (AliRICHHit*)pRICHhits->UncheckedAt(fHitIndex);
}
//_____________________________________________________________________________
Int_t chamber=display->GetChamber();
Int_t cathode=display->GetCathode();
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
- TClonesArray *RICHdigits = RICH->DigitsAddress(chamber-1);
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
+ TClonesArray *pRICHdigits = pRICH->DigitsAddress(chamber-1);
gAlice->TreeD()->GetEvent(cathode);
- Int_t ndigits = RICHdigits->GetEntriesFast();
+ Int_t ndigits = pRICHdigits->GetEntriesFast();
if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
- return (AliRICHDigit*)RICHdigits->UncheckedAt(fDigitIndex);
+ return (AliRICHDigit*)pRICHdigits->UncheckedAt(fDigitIndex);
}
//----------------------------------------------------------------------------
void AliRICHPoints::ShowRing(Int_t highlight) {
+
+//
+// Highlights all pads generated by the same mother particle
+
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH*)gAlice->GetDetector("RICH");
AliRICHChamber* iChamber;
AliRICHSegmentation* segmentation;
printf("Hit %d on chamber: %d\n",fHitIndex, mHit->fChamber);
- TClonesArray *digits = RICH->DigitsAddress(mHit->fChamber - 1);
- iChamber = &(RICH->Chamber(mHit->fChamber - 1));
+ TClonesArray *digits = pRICH->DigitsAddress(mHit->fChamber - 1);
+ iChamber = &(pRICH->Chamber(mHit->fChamber - 1));
segmentation=iChamber->GetSegmentationModel();
Float_t dpx = segmentation->Dpx();
points->SetMarkerSize(.5);
Float_t xpad, ypad;
segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY,xpad, ypad);
- Float_t VecLoc[3]={xpad,6.276,ypad};
- Float_t VecGlob[3];
+ Float_t vectorLoc[3]={xpad,6.276,ypad};
+ Float_t vectorGlob[3];
points->SetParticle(-1);
points->SetHitIndex(-1);
points->SetTrackIndex(-1);
points->SetDigitIndex(digit);
- iChamber->LocaltoGlobal(VecLoc,VecGlob);
- points->SetPoint(0,VecGlob[0],VecGlob[1],VecGlob[2]);
+ iChamber->LocaltoGlobal(vectorLoc,vectorGlob);
+ points->SetPoint(0,vectorGlob[0],vectorGlob[1],vectorGlob[2]);
segmentation->GetPadCxy(mdig->fPadX, mdig->fPadY, xpad, ypad);
Float_t theta = iChamber->GetRotMatrix()->GetTheta();
Float_t phi = iChamber->GetRotMatrix()->GetPhi();
- marker=new TMarker3DBox(VecGlob[0],VecGlob[1],VecGlob[2],
+ marker=new TMarker3DBox(vectorGlob[0],vectorGlob[1],vectorGlob[2],
dpy/2,0,dpx/2,theta,phi);
marker->SetLineColor(highlight);
marker->SetFillStyle(1001);
}
}
}
-//_____________________________________________________________________________
-struct Bin {
- const AliRICHDigit *dig;
- int idx;
- Bin() {dig=0; idx=-1;}
-};
-
-struct PreCluster : public AliRICHRawCluster {
- const AliRICHDigit* summit;
- int idx;
- int cut;
- int npeaks;
- PreCluster() : AliRICHRawCluster() {cut=npeaks=0;}
-};
-//_____________________________________________________________________________
-
-static void FindCluster(AliRICHChamber *iChamber, AliRICHSegmentation *segmentation, int i, int j, Bin bins[MAX_Nipx][MAX_Nipy], PreCluster &c)
-
-{
-
- //
- // Find clusters
- //
-
- printf("I'm in FindCluster \n");
-
- Bin& b=bins[i][j];
- Int_t q=b.dig->fSignal;
-
- printf("FindCluster - i j q %d %d %d\n",i,j,q);
-
- if (q<0) {
- q=-q;
- c.cut=1;
- }
- if (b.idx >= 0 && b.idx != c.idx) {
- c.idx=b.idx;
- c.npeaks++;
- }
-
- if (q > TMath::Abs(c.summit->fSignal)) c.summit=b.dig;
-
- Int_t npx = segmentation->Npx();
- Int_t npy = segmentation->Npy();
- Float_t x,y;
- segmentation->GetPadCxy(i-npx, j-npy, x,y);
- printf("FindCluster - x y %f %f \n",x,y);
-
-
- c.fX += q*x;
- c.fY += q*y;
- c.fQ += q;
-
- b.dig = 0; b.idx = c.idx;
-
- if (bins[i-1][j].dig) FindCluster(iChamber,segmentation,i-1,j,bins,c);
- if (bins[i][j-1].dig) FindCluster(iChamber,segmentation,i,j-1,bins,c);
- if (bins[i+1][j].dig) FindCluster(iChamber,segmentation,i+1,j,bins,c);
- if (bins[i][j+1].dig) FindCluster(iChamber,segmentation,i,j+1,bins,c);
-
-}
-
-//_____________________________________________________________________________
-
-void AliRICHPoints::GetCenterOfGravity()
-{
- //
- // simple RICH cluster finder from digits -- finds neighbours and
- // calculates center of gravity for the cluster
- //
- const Int_t MAX_nipx=400, MAX_nipy=800;
- printf("\n Hallo world");
- AliRICHDisplay *display=(AliRICHDisplay*)gAlice->Display();
- Int_t chamber=display->GetChamber();
- Int_t cathode=display->GetCathode();
-
- AliRICH *RICH = (AliRICH*)gAlice->GetDetector("RICH");
- AliRICHChamber *iChamber;
- AliRICHSegmentation *segmentation;
- iChamber =&(RICH->Chamber(chamber-1));
- segmentation=iChamber->GetSegmentationModel(cathode);
- Int_t npx = segmentation->Npx();
- Int_t npy = segmentation->Npy();
- Float_t zpos=iChamber->ZPosition();
-
- TClonesArray *RICHdigits = RICH->DigitsAddress(chamber-1);
- gAlice->TreeD()->GetEvent(cathode);
- Int_t ndigits = RICHdigits->GetEntriesFast();
- if (fDigitIndex < 0 || fDigitIndex >= ndigits) return;
-
- AliRICHDigit *dig;
- dig=(AliRICHDigit*)RICHdigits->UncheckedAt(fDigitIndex);
- Int_t ipx=dig->fPadX;
- Int_t ipy=dig->fPadY;
- Bin bins[MAX_nipx][MAX_nipy];
- bins[ipx+npx][ipy+npy].dig=dig;
-
- int ndig;
- int ncls=0;
- for (ndig=0; ndig<ndigits; ndig++) {
- dig = (AliRICHDigit*)RICHdigits->UncheckedAt(ndig);
- int i=dig->fPadX, j=dig->fPadY;
- bins[i+npx][j+npy].dig=dig;
- }
-
- PreCluster c; c.summit=bins[ipx+npx][ipy+npy].dig; c.idx=ncls;
- FindCluster(iChamber,segmentation,ipx+npx, ipy+npy, bins, c);
- if (c.npeaks>1) {
- printf("GetCenterOfGravity -- more than one peak");
- }
- c.fX /= c.fQ;
- c.fY /= c.fQ;
- printf("GetCenterOfGravity - c.fX c.fY c.fQ %f %f %d \n",c.fX,c.fY,c.fQ);
-
- c.fTracks[0]=c.summit->fTracks[0];
- c.fTracks[1]=c.summit->fTracks[1];
- c.fTracks[2]=c.summit->fTracks[2];
- ncls++;
- AliRICHPoints *points = 0;
- points = new AliRICHPoints(1);
- points->SetMarkerColor(kYellow);
- points->SetMarkerStyle(5);
- points->SetMarkerSize(1.);
- points->SetPoint(0,c.fX,c.fY,zpos);
- points->Draw();
-
- printf("GetCenterOfGravity -- ncls %d \n",ncls);
-
-}
//_____________________________________________________________________________
const Text_t *AliRICHPoints::GetName() const
-#ifndef AliRICHPoints_H
-#define AliRICHPoints_H
+#ifndef ALIRICHPOINTS_H
+#define ALIRICHPOINTS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
#include <TMarker3DBox.h>
#include "AliRICH.h"
#include "AliPoints.h"
+class AliRICHDigit;
class AliRICHPoints : public AliPoints {
-protected:
- Int_t fIndex; // Particle number in AliRun::fParticles
- Int_t fHitIndex; // Link to hit number
- Int_t fTrackIndex; // Link to track number
- Int_t fDigitIndex; // Link to digit
- TMarker3DBox *fMarker[3]; // pointer to associated 3D-marker
public:
AliRICHPoints();
AliRICHPoints(Int_t npoints);
virtual void DumpHit(); // *MENU*
virtual void InspectDigit(); // *MENU*
virtual void DumpDigit(); // *MENU*
- virtual void GetCenterOfGravity(); // *MENU*
virtual void ShowRing(Int_t highlight); // *MENU*
virtual void SetHitIndex(Int_t hitindex) {fHitIndex = hitindex;}
virtual void SetTrackIndex(Int_t trackindex) {fTrackIndex = trackindex;}
virtual void SetDigitIndex(Int_t digitindex) {fDigitIndex = digitindex;}
virtual void Set3DMarker(Int_t i,TMarker3DBox *marker) {fMarker[i] = marker;}
virtual void SetParticle(Int_t index) {fIndex = index;}
+ protected:
+ Int_t fIndex; // Particle number in AliRun::fParticles
+ Int_t fHitIndex; // Link to hit number
+ Int_t fTrackIndex; // Link to track number
+ Int_t fDigitIndex; // Link to digit
+ TMarker3DBox *fMarker[3]; // pointer to associated 3D-marker
+
ClassDef(AliRICHPoints,1) //Class to draw detector clusters (is PolyMarker3D)
};
#endif
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHRawCluster.h"
+
+
+ClassImp(AliRICHRawCluster)
+Int_t AliRICHRawCluster::Compare(TObject *obj)
+{
+
+// Compare two clusters
+
+ AliRICHRawCluster *raw=(AliRICHRawCluster *)obj;
+ Float_t y=fY;
+ Float_t yo=raw->fY;
+ if (y>yo) return 1;
+ else if (y<yo) return -1;
+ else return 0;
+
+}
+
+Int_t AliRICHRawCluster::
+BinarySearch(Float_t y, TArrayF coord, Int_t from, Int_t upto)
+{
+ // Find object using a binary search. Array must first have been sorted.
+ // Search can be limited by setting upto to desired index.
+
+ Int_t low=from, high=upto-1, half;
+ while(high-low>1) {
+ half=(high+low)/2;
+ if(y>coord[half]) low=half;
+ else high=half;
+ }
+ return low;
+}
+
+void AliRICHRawCluster::SortMin(Int_t *idx,Float_t *xdarray,Float_t *xarray,Float_t *yarray,Float_t *qarray, Int_t ntr)
+{
+ //
+ // Get the 3 closest points(cog) one can find on the second cathode
+ // starting from a given cog on first cathode
+ //
+
+ //
+ // Loop over deltax, only 3 times
+ //
+
+ Float_t xmin;
+ Int_t jmin;
+ Int_t id[3] = {-2,-2,-2};
+ Float_t jx[3] = {0.,0.,0.};
+ Float_t jy[3] = {0.,0.,0.};
+ Float_t jq[3] = {0.,0.,0.};
+ Int_t jid[3] = {-2,-2,-2};
+ Int_t i,j,imax;
+
+ if (ntr<3) imax=ntr;
+ else imax=3;
+ for(i=0;i<imax;i++){
+ xmin=1001.;
+ jmin=0;
+
+ for(j=0;j<ntr;j++){
+ if ((i == 1 && j == id[i-1])
+ ||(i == 2 && (j == id[i-1] || j == id[i-2]))) continue;
+ if (TMath::Abs(xdarray[j]) < xmin) {
+ xmin = TMath::Abs(xdarray[j]);
+ jmin=j;
+ }
+ } // j
+ if (xmin != 1001.) {
+ id[i]=jmin;
+ jx[i]=xarray[jmin];
+ jy[i]=yarray[jmin];
+ jq[i]=qarray[jmin];
+ jid[i]=idx[jmin];
+ }
+
+ } // i
+
+ for (i=0;i<3;i++){
+ if (jid[i] == -2) {
+ xarray[i]=1001.;
+ yarray[i]=1001.;
+ qarray[i]=1001.;
+ idx[i]=-1;
+ } else {
+ xarray[i]=jx[i];
+ yarray[i]=jy[i];
+ qarray[i]=jq[i];
+ idx[i]=jid[i];
+ }
+ }
+
+}
+
+
+Int_t AliRICHRawCluster::PhysicsContribution()
+{
+
+// Type of physics processes
+
+ Int_t iPhys=0;
+ Int_t iBg=0;
+ Int_t iMixed=0;
+ for (Int_t i=0; i<fMultiplicity; i++) {
+ if (fPhysicsMap[i]==2) iPhys++;
+ if (fPhysicsMap[i]==1) iMixed++;
+ if (fPhysicsMap[i]==0) iBg++;
+ }
+ if (iMixed==0 && iBg==0) {
+ return 2;
+ } else if ((iPhys != 0 && iBg !=0) || iMixed != 0) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
--- /dev/null
+#ifndef ALIRICHRAWCLUSTER_H
+#define ALIRICHRAWCLUSTER_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+#include <TObject.h>
+#include <TMath.h>
+#include <TArrayF.h>
+
+
+class AliRICHRawCluster : public TObject {
+public:
+ Int_t fTracks[3]; //labels of overlapped tracks
+ Int_t fQ ; // Q of cluster (in ADC counts)
+ Float_t fX ; // X of cluster
+ Float_t fY ; // Y of cluster
+ Int_t fPeakSignal; // Charge in the peak
+ Int_t fIndexMap[50]; //indeces of digits
+ Int_t fOffsetMap[50]; // offset map
+ Float_t fContMap[50]; //Contribution from digit
+ Int_t fPhysicsMap[50]; // physics processes
+ Int_t fMultiplicity; //cluster multiplicity
+ Int_t fNcluster[2]; //number of clusters
+ Int_t fClusterType; //??
+ Int_t fCtype; //CL0, CL1, etc...
+ public:
+ AliRICHRawCluster() {
+ fTracks[0]=fTracks[1]=fTracks[2]=-1;
+ fQ=0; fX=fY=0; fMultiplicity=0;
+ for (int k=0;k<50;k++) {
+ fIndexMap[k]=-1;
+ fOffsetMap[k]=0;
+ fContMap[k]=0;
+ fPhysicsMap[k]=-1;
+ fCtype=-1;
+ }
+ fNcluster[0]=fNcluster[1]=-1;
+ }
+ virtual ~AliRICHRawCluster() {}
+
+ Float_t GetRadius() {return TMath::Sqrt(fX*fX+fY*fY);}
+
+ Bool_t IsSortable() const {return kTRUE;}
+ Int_t Compare(TObject *obj);
+ Int_t PhysicsContribution();
+ static Int_t BinarySearch(Float_t r, TArrayF coord, Int_t from, Int_t upto);
+ static void SortMin(Int_t *idx,Float_t *xdarray,Float_t *xarray,Float_t *yarray,Float_t *qarray,Int_t ntr);
+
+ ClassDef(AliRICHRawCluster,1) //Cluster object for set:RICH
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHRecHit.h"
+
+ClassImp(AliRICHRecHit)
+
+AliRICHRecHit::AliRICHRecHit(Int_t id, Float_t *rechit)
+{
+ //
+ // Creates a RICH rec. hit object
+ //
+ fTheta = rechit[0];
+ fPhi = rechit[1];
+ fOmega = rechit[2];
+ fX = rechit[3];
+ fY = rechit[4];
+}
+
+
--- /dev/null
+#ifndef ALIRICHRECHIT_H
+#define ALIRICHRECHIT_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+#include <TObject.h>
+class AliRICHRecHit : public TObject {
+public:
+ Float_t fTheta ; //Incidence Angle theta
+ Float_t fPhi ; //Incidence Angle phi
+ Float_t fOmega; //Cherenkov angle omega
+ Float_t fX; //Impact coordinate x
+ Float_t fY; //Impact coordinate y
+ public:
+ AliRICHRecHit() {
+ fTheta=fPhi=fOmega=0;
+ }
+ AliRICHRecHit(Int_t id, Float_t* rechit);
+ virtual ~AliRICHRecHit() {}
+ ClassDef(AliRICHRecHit,1) //Reconstructed hit object for set:RICH
+};
+
+#endif
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+#include "AliRICHResponse.h"
+
+ClassImp(AliRICHResponse)
--- /dev/null
+#ifndef ALIRICHRESPONSE_H
+#define ALIRICHRESPONSE_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+
+//----------------------------------------------
+//
+// Chamber response virtual base class
+//
+#include <TObject.h>
+class AliRICHSegmentation;
+
+
+class AliRICHResponse :
+public TObject {
+ public:
+ //
+ // Configuration methods
+ //
+ // Number of sigmas over which cluster didintegration is performed
+ virtual void SetSigmaIntegration(Float_t p1) =0;
+ virtual Float_t SigmaIntegration() =0;
+ // charge slope in ADC/e
+ virtual void SetChargeSlope(Float_t p1) =0;
+ virtual Float_t ChargeSlope() =0;
+ // sigma of the charge spread function
+ virtual void SetChargeSpread(Float_t p1, Float_t p2) =0;
+ virtual Float_t ChargeSpreadX() =0;
+ virtual Float_t ChargeSpreadY() =0;
+ // Adc-count saturation value
+ virtual void SetMaxAdc(Float_t p1) =0;
+ virtual Float_t MaxAdc() =0;
+ // anode cathode Pitch
+ virtual void SetPitch(Float_t) =0;
+ virtual Float_t Pitch() =0;
+ // alpha feedback
+ virtual void SetAlphaFeedback(Float_t) =0;
+ virtual Float_t AlphaFeedback() =0;
+ // ionisation enrgy
+ virtual void SetEIonisation(Float_t) =0;
+ virtual Float_t EIonisation() =0;
+ // Chamber response methods
+ // Pulse height from scored quantity (eloss)
+ virtual Float_t IntPH(Float_t eloss) =0;
+ virtual Float_t IntPH() =0;
+ // Charge disintegration
+ virtual Float_t IntXY(AliRICHSegmentation *) =0;
+ virtual Int_t FeedBackPhotons(Float_t *source, Float_t qtot) =0;
+ //
+ // Mathieson parameters
+ virtual void SetSqrtKx3(Float_t p1) =0;
+ virtual void SetKx2(Float_t p1) =0;
+ virtual void SetKx4(Float_t p1) =0;
+ virtual void SetSqrtKy3(Float_t p1) =0;
+ virtual void SetKy2(Float_t p1) =0;
+ virtual void SetKy4(Float_t p1) =0;
+ ClassDef(AliRICHResponse,1)
+};
+
+#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+#include "AliRICHResponseV0.h"
+#include "AliRICHSegmentation.h"
+#include "AliRun.h"
+
+#include <TMath.h>
+#include <TRandom.h>
+#include <TParticle.h>
+//___________________________________________
+ClassImp(AliRICHResponseV0)
+
+Float_t AliRICHResponseV0::IntPH(Float_t eloss)
+{
+ // Get number of electrons and return charge
+
+ Int_t nel;
+ nel= Int_t(eloss/fEIonisation);
+
+ Float_t charge=0;
+ if (nel == 0) nel=1;
+ for (Int_t i=1;i<=nel;i++) {
+ charge -= fChargeSlope*TMath::Log(gRandom->Rndm());
+ }
+ return charge;
+}
+
+Float_t AliRICHResponseV0::IntPH()
+{
+
+// Get number of electrons and return charge, for a single photon
+
+ Float_t charge = -fChargeSlope*TMath::Log(gRandom->Rndm());
+ return charge;
+}
+
+
+
+// -------------------------------------------
+Float_t AliRICHResponseV0::IntXY(AliRICHSegmentation * segmentation)
+{
+
+ const Float_t kInversePitch = 1/fPitch;
+ Float_t response;
+//
+// Integration limits defined by segmentation model
+//
+
+ Float_t xi1, xi2, yi1, yi2;
+ segmentation->IntegrationLimits(xi1,xi2,yi1,yi2);
+
+ xi1=xi1*kInversePitch;
+ xi2=xi2*kInversePitch;
+ yi1=yi1*kInversePitch;
+ yi2=yi2*kInversePitch;
+
+ //printf("Integration Limits: %f-%f, %f-%f\n",xi1,xi2,yi1,yi2);
+
+ //printf("KInversePitch:%f\n",kInversePitch);
+
+ //
+// The Mathieson function
+ Double_t ux1=fSqrtKx3*TMath::TanH(fKx2*xi1);
+ Double_t ux2=fSqrtKx3*TMath::TanH(fKx2*xi2);
+
+ Double_t uy1=fSqrtKy3*TMath::TanH(fKy2*yi1);
+ Double_t uy2=fSqrtKy3*TMath::TanH(fKy2*yi2);
+
+ //printf("Integration Data: %f-%f, %f-%f\n",ux1,ux2,uy1,uy2);
+
+ //printf("%f %f %f %f\n",fSqrtKx3,fKx2,fKy4,fKx4);
+
+ response=4.*fKx4*(TMath::ATan(ux2)-TMath::ATan(ux1))*fKy4*(TMath::ATan(uy2)-TMath::ATan(uy1));
+
+ //printf("Response:%f\n",response);
+
+ return response;
+
+}
+
+Int_t AliRICHResponseV0::FeedBackPhotons(Float_t *source, Float_t qtot)
+{
+ //
+ // Generate FeedBack photons
+ //
+ Int_t j, ipart, nt;
+
+ Int_t sNfeed=0;
+
+
+ // Local variables
+ Float_t cthf, ranf[2], phif, enfp = 0, sthf;
+ Int_t i, ifeed;
+ Float_t e1[3], e2[3], e3[3];
+ Float_t vmod, uswop;
+ Float_t fp, random;
+ Float_t dir[3], phi;
+ Int_t nfp;
+ Float_t pol[3], mom[3];
+ TLorentzVector position;
+ //
+ // Determine number of feedback photons
+
+ // Get weight of current particle
+ TParticle *current = (TParticle*)
+ (*gAlice->Particles())[gAlice->CurrentTrack()];
+
+ ifeed = Int_t(current->GetWeight()/100+0.5);
+ ipart = gMC->TrackPid();
+ fp = fAlphaFeedback * qtot;
+ nfp = gRandom->Poisson(fp);
+
+ // This call to fill the time of flight
+ gMC->TrackPosition(position);
+ //
+ // Generate photons
+ for (i = 0; i <nfp; i++) {
+
+ // Direction
+ gMC->Rndm(ranf, 2);
+ cthf = ranf[0] * 2 - 1.;
+ if (cthf < 0) continue;
+ sthf = TMath::Sqrt((1 - cthf) * (1 + cthf));
+ phif = ranf[1] * 2 * TMath::Pi();
+ //
+ gMC->Rndm(&random, 1);
+ if (random <= .57) {
+ enfp = 7.5e-9;
+ } else if (random <= .7) {
+ enfp = 6.4e-9;
+ } else {
+ enfp = 7.9e-9;
+ }
+
+ dir[0] = sthf * TMath::Sin(phif);
+ dir[1] = cthf;
+ dir[2] = sthf * TMath::Cos(phif);
+ gMC->Gdtom(dir, mom, 2);
+ mom[0]*=enfp;
+ mom[1]*=enfp;
+ mom[2]*=enfp;
+
+ // Polarisation
+ e1[0] = 0;
+ e1[1] = -dir[2];
+ e1[2] = dir[1];
+
+ e2[0] = -dir[1];
+ e2[1] = dir[0];
+ e2[2] = 0;
+
+ e3[0] = dir[1];
+ e3[1] = 0;
+ e3[2] = -dir[0];
+
+ vmod=0;
+ for(j=0;j<3;j++) vmod+=e1[j]*e1[j];
+ if (!vmod) for(j=0;j<3;j++) {
+ uswop=e1[j];
+ e1[j]=e3[j];
+ e3[j]=uswop;
+ }
+ vmod=0;
+ for(j=0;j<3;j++) vmod+=e2[j]*e2[j];
+ if (!vmod) for(j=0;j<3;j++) {
+ uswop=e2[j];
+ e2[j]=e3[j];
+ e3[j]=uswop;
+ }
+
+ vmod=0;
+ for(j=0;j<3;j++) vmod+=e1[j]*e1[j];
+ vmod=TMath::Sqrt(1/vmod);
+ for(j=0;j<3;j++) e1[j]*=vmod;
+
+ vmod=0;
+ for(j=0;j<3;j++) vmod+=e2[j]*e2[j];
+ vmod=TMath::Sqrt(1/vmod);
+ for(j=0;j<3;j++) e2[j]*=vmod;
+
+ gMC->Rndm(ranf, 1);
+ phi = ranf[0] * 2 * TMath::Pi();
+ for(j=0;j<3;j++) pol[j]=e1[j]*TMath::Sin(phi)+e2[j]*TMath::Cos(phi);
+ gMC->Gdtom(pol, pol, 2);
+
+ // Put photon on the stack and label it as feedback (51, 52)
+ ++sNfeed;
+
+ gAlice->SetTrack(Int_t(1), gAlice->CurrentTrack(), Int_t(50000051),
+ mom,source,pol,position[3],
+ "Feedback", nt, 1.);
+ }
+ return(sNfeed);
+}
+
+
+
+
--- /dev/null
+#ifndef ALIRICHRESPONSEV0_H
+#define ALIRICHRESPONSEV0_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+
+#include "AliRICHResponse.h"
+
+class AliRICHResponseV0 : //Mathieson response
+public AliRICHResponse {
+ public:
+ AliRICHResponseV0(){}
+ virtual ~AliRICHResponseV0(){}
+ //
+ // Configuration methods
+ //
+ // Number of sigmas over which cluster didintegration is performed
+ virtual void SetSigmaIntegration(Float_t p1) {fSigmaIntegration=p1;}
+ virtual Float_t SigmaIntegration() {return fSigmaIntegration;}
+ // charge slope in ADC/e
+ virtual void SetChargeSlope(Float_t p1) {fChargeSlope=p1;}
+ virtual Float_t ChargeSlope() {return fChargeSlope;}
+ // sigma of the charge spread function
+ virtual void SetChargeSpread(Float_t p1, Float_t p2)
+ {fChargeSpreadX=p1; fChargeSpreadY=p2;}
+ virtual Float_t ChargeSpreadX() {return fChargeSpreadX;}
+ virtual Float_t ChargeSpreadY() {return fChargeSpreadY;}
+ // Adc-count saturation value
+ virtual void SetMaxAdc(Float_t p1) {fMaxAdc=p1;}
+ virtual Float_t MaxAdc() {return fMaxAdc;}
+ // anode cathode Pitch
+ virtual Float_t Pitch() {return fPitch;}
+ virtual void SetPitch(Float_t p1) {fPitch=p1;};
+ // alpha feedback
+ virtual void SetAlphaFeedback(Float_t alpha) {fAlphaFeedback=alpha;}
+ virtual Float_t AlphaFeedback() {return fAlphaFeedback;}
+ // ionisation enrgy
+ virtual void SetEIonisation(Float_t e) {fEIonisation=e;}
+ virtual Float_t EIonisation() {return fEIonisation;}
+ // Mathieson parameters
+ virtual void SetSqrtKx3(Float_t p1) {fSqrtKx3=p1;};
+ virtual void SetKx2(Float_t p1) {fKx2=p1;};
+ virtual void SetKx4(Float_t p1) {fKx4=p1;};
+ virtual void SetSqrtKy3(Float_t p1) {fSqrtKy3=p1;};
+ virtual void SetKy2(Float_t p1) {fKy2=p1;};
+ virtual void SetKy4(Float_t p1) {fKy4=p1;};
+ //
+ // Chamber response methods
+ // Pulse height from scored quantity (eloss)
+ virtual Float_t IntPH(Float_t eloss);
+ virtual Float_t IntPH();
+ // Charge disintegration
+ virtual Float_t IntXY(AliRICHSegmentation * segmentation);
+ virtual Int_t FeedBackPhotons(Float_t *source, Float_t qtot);
+ protected:
+ Float_t fChargeSlope; // Slope of the charge distribution
+ Float_t fChargeSpreadX; // Width of the charge distribution in x
+ Float_t fChargeSpreadY; // Width of the charge distribution in y
+ Float_t fSigmaIntegration; // Number of sigma's used for charge distribution
+ Float_t fAlphaFeedback; // Feedback photons coefficient
+ Float_t fEIonisation; // Mean ionisation energy
+ Float_t fMaxAdc; // Maximum ADC channel
+ Float_t fSqrtKx3; // Mathieson parameters for x
+ Float_t fKx2; // Mathieson parameters for x
+ Float_t fKx4; // Mathieson parameters for x
+ Float_t fSqrtKy3; // Mathieson parameters for y
+ Float_t fKy2; // Mathieson parameters for y
+ Float_t fKy4; // Mathieson parameters for y
+ Float_t fPitch; //anode-cathode pitch
+ ClassDef(AliRICHResponseV0,1)
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+#include "AliRICHSegmentation.h"
+
+ClassImp(AliRICHSegmentation)
--- /dev/null
+#ifndef ALIRICHSEGMENTATION_H
+#define ALIRICHSEGMENTATION_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include <TObject.h>
+
+class AliRICHChamber;
+class TF1;
+class AliRICHSegmentation :
+
+public TObject {
+
+ public:
+
+ // Set Chamber Segmentation Parameters
+ //
+ // Pad size Dx*Dy
+ virtual void SetPadSize(Float_t p1, Float_t p2) =0;
+ // Anod Pitch
+ virtual void SetDAnod(Float_t D) =0;
+
+ //
+ // Anod wire coordinate closest to xhit
+ virtual Float_t GetAnod(Float_t xhit) =0;
+ // Transform from pad (wire) to real coordinates
+ virtual void GetPadIxy(Float_t x ,Float_t y ,Int_t &ix,Int_t &iy)=0;
+ // Transform from real to pad coordinates
+ virtual void GetPadCxy(Int_t ix,Int_t iy,Float_t &x ,Float_t &y )=0;
+ //
+ // Initialisation
+ virtual void Init(AliRICHChamber*) =0;
+ //
+ // Get member data
+ //
+ // Pad size in x
+ virtual Float_t Dpx() =0;
+ // Pad size in y
+ virtual Float_t Dpy() =0;
+ // Pad size in x by Sector
+ virtual Float_t Dpx(Int_t) =0;
+ // Pad size in y by Sector
+ virtual Float_t Dpy(Int_t) =0;
+ // Max number of Pads in x
+ virtual Int_t Npx() =0;
+ // Max number of Pads in y
+ virtual Int_t Npy() =0;
+
+
+ // set pad position
+ virtual void SetPad(Int_t, Int_t) =0;
+ // set hit position
+ virtual void SetHit(Float_t, Float_t) =0;
+ //
+ // Iterate over pads
+ // Initialiser
+ virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy) =0;
+ // Stepper
+ virtual void NextPad()=0;
+ // Condition
+ virtual Int_t MorePads() =0;
+ //
+ // Distance between 1 pad and a position
+ virtual Float_t Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t *dummy) =0;
+ // Number of pads read in parallel and offset to add to x
+ // (specific to LYON, but mandatory for display)
+ virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
+ Int_t *Nparallel, Int_t *Offset) =0;
+ // Get next neighbours
+ virtual void Neighbours
+ (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) =0;
+ //
+ // Current pad cursor during disintegration
+ // x-coordinate
+ virtual Int_t Ix() =0;
+ // y-coordinate
+ virtual Int_t Iy() =0;
+ // current Sector
+ virtual Int_t ISector() =0;
+ // calculate sector from pad coordinates
+ virtual Int_t Sector(Float_t ix, Float_t iy) =0;
+ //
+ // Signal Generation Condition during Stepping
+ virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) = 0;
+ // Initialise signal gneration at coord (x,y,z)
+ virtual void SigGenInit(Float_t x, Float_t y, Float_t z) = 0;
+ // Current integration limits
+ virtual void IntegrationLimits
+ (Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2) = 0;
+ // Test points for auto calibration
+ virtual void GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) = 0;
+ // Debug utilities
+ virtual void Draw() = 0;
+ // Function for systematic corrections
+ virtual void SetCorrFunc(Int_t, TF1*) = 0;
+ virtual TF1* CorrFunc(Int_t) = 0;
+ ClassDef(AliRICHSegmentation,1)
+
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+#include "AliRICHSegmentationV0.h"
+
+
+ClassImp(AliRICHSegmentationV0)
+
+void AliRICHSegmentationV0::Init(AliRICHChamber* Chamber)
+{
+
+// Initialisation of chambers
+
+ //fNpx=(Int_t) (Chamber->ROuter()/fDpx+1);
+ //fNpy=(Int_t) (Chamber->ROuter()/fDpy+1);
+ fNpx=160;
+ fNpy=144;
+ //fNpx=80;
+ //fNpy=48;
+ fSector=-1;
+}
+
+
+Float_t AliRICHSegmentationV0::GetAnod(Float_t xhit)
+{
+
+// Get anod wire closer to hit
+
+ Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
+ return fWireD*wire;
+}
+
+void AliRICHSegmentationV0::SetPadSize(Float_t p1, Float_t p2)
+{
+
+// Set the pad size
+
+ fDpx=p1;
+ fDpy=p2;
+}
+void AliRICHSegmentationV0::GetPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
+{
+// returns pad coordinates (ix,iy) for given real coordinates (x,y)
+//
+// Please check origin of pad numbering !!!
+
+
+ ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx);
+ iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy);
+ if (iy > fNpy) iy= fNpy;
+ if (iy < -fNpy) iy=-fNpy;
+ if (ix > fNpx) ix= fNpx;
+ if (ix < -fNpx) ix=-fNpx;
+}
+void AliRICHSegmentationV0::
+GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
+{
+// returns real coordinates (x,y) for given pad coordinates (ix,iy)
+//
+
+ x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)-fDpx/2.;
+ y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)-fDpy/2.;
+}
+
+void AliRICHSegmentationV0::
+SetHit(Float_t xhit, Float_t yhit)
+{
+//
+// Find the wire position (center of charge distribution)
+// Float_t x0a=GetAnod(xhit);
+ fxhit=xhit;
+ fyhit=yhit;
+}
+
+void AliRICHSegmentationV0::
+SetPad(Int_t ix, Int_t iy)
+{
+
+// Move to pad ix, iy
+
+ GetPadCxy(ix,iy,fx,fy);
+}
+
+
+
+void AliRICHSegmentationV0::
+FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
+{
+
+ //
+ // Find the wire position (center of charge distribution)
+ Float_t x0a=GetAnod(xhit);
+ fxhit=x0a;
+ fyhit=yhit;
+ //
+ // and take fNsigma*sigma around this center
+ Float_t x01=x0a - dx;
+ Float_t x02=x0a + dx;
+ Float_t y01=yhit - dy;
+ Float_t y02=yhit + dy;
+ //
+ // find the pads over which the charge distributes
+ GetPadIxy(x01,y01,fixmin,fiymin);
+ GetPadIxy(x02,y02,fixmax,fiymax);
+ //
+ // Set current pad to lower left corner
+ fix=fixmin;
+ fiy=fiymin;
+ GetPadCxy(fix,fiy,fx,fy);
+
+ //if (fSector==2)
+ //printf("fix: %d, fiy: %d fx: %f, fy: %f\n",fix,fiy,fx,fy);
+}
+
+void AliRICHSegmentationV0::NextPad()
+{
+ //printf("\n Next Pad \n");
+
+ //
+ // Step to next pad in integration region
+ if (fix <= fixmax) {
+// if (fix==-1) fix++;
+ fix++;
+ } else if (fiy <= fiymax) {
+// if (fiy==-1) fiy++;
+ fix=fixmin;
+ fiy++;
+ } else {
+ printf("\n Error: Stepping outside integration region\n ");
+ }
+ GetPadCxy(fix,fiy,fx,fy);
+}
+
+Int_t AliRICHSegmentationV0::MorePads()
+
+{
+//
+// Are there more pads in the integration region
+
+ //printf("\n More Pads ? \n");
+
+
+ if (fix >= fixmax && fiy >= fiymax) {
+ //printf("There are no more pads\n\n\n\n\n");
+ return 0;
+ } else {
+ //printf("There are more pads\n\n");
+ return 1;
+ }
+}
+
+void AliRICHSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t)
+{
+//
+// Initialises pad and wire position during stepping
+ fxt =x;
+ fyt =y;
+ GetPadIxy(x,y,fixt,fiyt);
+ fiwt= (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
+}
+
+Int_t AliRICHSegmentationV0::SigGenCond(Float_t x,Float_t y,Float_t)
+{
+//
+// Signal will be generated if particle crosses pad boundary or
+// boundary between two wires.
+ Int_t ixt, iyt;
+ GetPadIxy(x,y,ixt,iyt);
+ Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1;
+
+ if ((ixt != fixt) || (iyt !=fiyt) || (iwt != fiwt)) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+void AliRICHSegmentationV0::
+IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
+{
+
+// Calculate the integration limits
+
+/*
+ x1=fxt-fx-fDpx/2.;
+ x2=x1+fDpx;
+ y1=fyt-fy-fDpy/2.;
+ y2=y1+fDpy;
+*/
+ x1=fxhit-fx-fDpx/2.;
+ x2=x1+fDpx;
+ y1=fyhit-fy-fDpy/2.;
+ y2=y1+fDpy;
+}
+
+void AliRICHSegmentationV0::
+Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[7], Int_t Ylist[7])
+{
+//Is used for the cluster finder, include diagonal elements
+
+ *Nlist=4;Xlist[0]=Xlist[1]=iX;Xlist[2]=iX-1;Xlist[3]=iX+1;
+ Ylist[0]=iY-1;Ylist[1]=iY+1;Ylist[2]=Ylist[3]=iY;
+/*
+ *Nlist=8;
+ Xlist[0]=Xlist[1]=iX;
+ Xlist[2]=iX-1;
+ Xlist[3]=iX+1;
+ Ylist[0]=iY-1;
+ Ylist[1]=iY+1;
+ Ylist[2]=Ylist[3]=iY;
+
+ // Diagonal elements
+ Xlist[4]=iX+1;
+ Ylist[4]=iY+1;
+
+ Xlist[5]=iX-1;
+ Ylist[5]=iY-1;
+
+ Xlist[6]=iX-1;
+ Ylist[6]=iY+1;
+
+ Xlist[7]=iX+1;
+ Ylist[7]=iY-1;
+*/
+}
+
+Float_t AliRICHSegmentationV0::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y
+, Int_t *dummy)
+
+{
+// Returns the square of the distance between 1 pad
+// labelled by its Channel numbers and a coordinate
+
+ Float_t x,y;
+ GetPadCxy(iX,iY,x,y);
+ return (x-X)*(x-X) + (y-Y)*(y-Y);
+}
+
+
+void AliRICHSegmentationV0::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y)
+{
+
+// Test
+
+ n=1;
+ x[0]=0.;
+ y[0]=x[0];
+}
+
+void AliRICHSegmentationV0::Draw()
+{
+
+// Dummy draw routine
+
+/*
+ TArc *circle;
+ Float_t scale=0.95/fRmax/2.;
+
+
+ circle = new TArc(0.5,0.5,fRmax*scale,0.,360.);
+ circle->SetFillColor(2);
+ circle->Draw();
+
+ circle = new TArc(0.5,0.5,fRmin*scale,0.,360.);
+ circle->SetFillColor(1);
+ circle->Draw();
+*/
+ ;
+
+}
--- /dev/null
+#ifndef ALIRICHSEGMENTATIONV0_H
+#define ALIRICHSEGMENTATIONV0_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include "AliRICHSegmentation.h"
+
+class AliRICHSegmentationV0 :
+public AliRICHSegmentation {
+ public:
+ AliRICHSegmentationV0(){}
+ virtual ~AliRICHSegmentationV0(){}
+ //
+ // Set Chamber Segmentation Parameters
+ //
+ // Pad size Dx*Dy
+ virtual void SetPadSize(Float_t p1, Float_t p2);
+ // Anod Pitch
+ virtual void SetDAnod(Float_t D) {fWireD = D;};
+
+ //
+ // Transform from pad (wire) to real coordinates and vice versa
+ //
+ // Anod wire coordinate closest to xhit
+ virtual Float_t GetAnod(Float_t xhit);
+ // Transform from pad to real coordinates
+ virtual void GetPadIxy(Float_t x ,Float_t y ,Int_t &ix,Int_t &iy);
+ // Transform from real to pad coordinates
+ virtual void GetPadCxy(Int_t ix,Int_t iy,Float_t &x ,Float_t &y );
+ //
+ // Initialisation
+ virtual void Init(AliRICHChamber* chamber);
+ //
+ // Get member data
+ //
+ // Pad size in x
+ virtual Float_t Dpx(){return fDpx;}
+ //
+ // Pad size in y
+ virtual Float_t Dpy(){return fDpy;}
+ // Pad size in x by Sector
+ virtual Float_t Dpx(Int_t) {return fDpx;}
+ // Pad size in y by Sector
+ virtual Float_t Dpy(Int_t) {return fDpy;}
+ // Max number of Pads in x
+ virtual Int_t Npx(){return fNpx;}
+ // Max number of Pads in y
+ virtual Int_t Npy(){return fNpy;}
+
+
+ // set pad position
+ virtual void SetPad(Int_t ix, Int_t iy);
+ // set hit position
+ virtual void SetHit(Float_t xhit , Float_t yhit);
+ //
+ // Iterate over pads
+ // Initialiser
+ virtual void FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy);
+ // Stepper
+ virtual void NextPad();
+ // Condition
+ virtual Int_t MorePads();
+ //
+ // Distance between 1 pad and a position
+ virtual Float_t Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t *
+ dummy);
+ // Number of pads read in parallel and offset to add to x
+ // (specific to LYON, but mandatory for display)
+ virtual void GetNParallelAndOffset(Int_t iX, Int_t iY,
+ Int_t *Nparallel, Int_t *Offset) {*Nparallel=1;*Offset=0;}
+ // Get next neighbours
+ virtual void Neighbours
+ (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);
+ //
+ // Current Pad during Integration
+ // x-coordinate
+ virtual Int_t Ix(){return fix;}
+ // y-coordinate
+ virtual Int_t Iy(){return fiy;}
+ // current sector
+ virtual Int_t ISector(){return 1;}
+ // calculate sector from x-y coordinates
+ virtual Int_t Sector(Float_t x, Float_t y){return 1;}
+ //
+ // Signal Generation Condition during Stepping
+ virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z);
+ // Initialise signal gneration at coord (x,y,z)
+ virtual void SigGenInit(Float_t x, Float_t y, Float_t z);
+ // Current integration limits
+ virtual void IntegrationLimits
+ (Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2);
+ // Test points for auto calibration
+ virtual void GiveTestPoints(Int_t &n, Float_t *x, Float_t *y);
+ // Debugging utilities
+ virtual void Draw();
+ // Function for systematic corrections
+ virtual void SetCorrFunc(Int_t dum, TF1* func) {fCorr=func;}
+
+ virtual TF1* CorrFunc(Int_t) {return fCorr;}
+ ClassDef(AliRICHSegmentationV0,1)
+ protected:
+ //
+ // Implementation of the segmentation data
+ // Version 0 models rectangular pads with the same dimensions all
+ // over the cathode plane
+ //
+ // geometry
+ //
+ Float_t fDpx; // x pad width per sector
+ Float_t fDpy; // y pad base width
+ Int_t fNpx; // Number of pads in x
+ Int_t fNpy; // Number of pads in y
+ Int_t fSector; // Current padplane
+ Float_t fWireD; // wire pitch
+
+
+
+ // Chamber region consideres during disintegration (lower left and upper right corner)
+ //
+ Int_t fixmin; // lower left x
+ Int_t fixmax; // lower left y
+ Int_t fiymin; // upper right x
+ Int_t fiymax; // upper right y
+ //
+ // Current pad during integration (cursor for disintegration)
+ Int_t fix; // pad coord. x
+ Int_t fiy; // pad coord. y
+ Float_t fx; // x
+ Float_t fy; // y
+ //
+ // Current pad and wire during tracking (cursor at hit centre)
+ Float_t fxhit; //x position
+ Float_t fyhit; //y position
+ // Reference point to define signal generation condition
+ Int_t fixt; // pad coord. x
+ Int_t fiyt; // pad coord. y
+ Int_t fiwt; // wire number
+ Float_t fxt; // x
+ Float_t fyt; // y
+ TF1* fCorr; // correction function
+};
+#endif
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+#include "AliRICHSegmentationV1.h"
+
+
+//--------------------------------------------------------
+ClassImp(AliRICHSegmentationV1)
+
+//________________________________________________________________________________
+AliRICHSegmentationV1::AliRICHSegmentationV1()
+{
+
+// Default constructor for AliRICHSegmantionV1 (with dead zones)
+
+ fNpx=160;
+ fNpy=144;
+ //fNpx=80;
+ //fNpy=48;
+ fSector=-1;
+}
+
+//________________________________________________________________________________
+AliRICHSegmentationV1::~AliRICHSegmentationV1()
+{
+// Destructor
+
+}
+
+
+// calculate sector from x-y coordinates
+
+Int_t AliRICHSegmentationV1::Sector(Float_t x, Float_t y)
+{
+
+// Calculate in which sector is the hit
+
+ fSector=-1;
+
+ if (x<-1.3)
+ {
+ if (y>22.75)
+ {
+ if (y<63.1)
+ fSector=0;
+ }
+ if (y<20.15)
+ {
+ if (y>(-20.15))
+ fSector=2;
+ }
+ if (y<(-22.75))
+ {
+ if (y>(-63.1))
+ fSector=4;
+ }
+ }
+ else if (x>1.3)
+ {
+ if (y>22.75)
+ {
+ if (y<63.1)
+ fSector=1;
+ }
+ if (y<20.15)
+ {
+ if (y>(-20.15))
+ fSector=3;
+ }
+ if (y<(-22.75))
+ {
+ if (y>(-63.1))
+ fSector=5;
+ }
+ }
+
+ //if (fSector==2)
+ //printf("x:%f, y:%f, sector:%d\n",x,y,fSector);
+
+ return fSector;
+}
+
+
+void AliRICHSegmentationV1::GetPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
+{
+// returns pad coordinates (ix,iy) for given real coordinates (x,y)
+//
+// Please check origin of pad numbering !!!
+
+ Int_t sector=Sector(x,y);
+
+ //printf("Sector: %d\n",sector);
+
+
+ if (sector==0)
+ {
+ //ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx);
+ //iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy);
+ ix = Int_t (x/fDpx+1.3);
+ iy = Int_t (y/fDpy-2.6);
+ }
+ if (sector==1)
+ {
+ ix = Int_t (x/fDpx-1.3);
+ iy = Int_t (y/fDpy-2.6);
+ }
+ if (sector==2)
+ {
+ ix = Int_t (x/fDpx+1.3);
+ iy = Int_t (y/fDpy);
+ }
+ if (sector==3)
+ {
+ ix = Int_t (x/fDpx-1.3);
+ iy = Int_t (y/fDpy);
+ }
+ if (sector==4)
+ {
+ ix = Int_t (x/fDpx+1.3);
+ iy = Int_t (y/fDpy+2.6);
+ }
+ if (sector==5)
+ {
+ ix = Int_t (x/fDpx-1.3);
+ iy = Int_t (y/fDpy+2.6);
+ }
+
+ //ix = Int_t (x/fDpx);
+ //iy = Int_t (y/fDpy);
+
+ //ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx);
+ //iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy);
+
+ if (sector==-1)
+ {
+ ix = fixmax;
+ iy = fiymax;
+ }
+
+ if (iy > fNpy) iy= fNpy;
+ if (iy < -fNpy) iy=-fNpy;
+ if (ix > fNpx) ix= fNpx;
+ if (ix < -fNpx) ix=-fNpx;
+}
+
+void AliRICHSegmentationV1::
+GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
+{
+// returns real coordinates (x,y) for given pad coordinates (ix,iy)
+//
+
+ //Int_t sector=Sector(ix*.8,iy*.84);
+
+ Int_t sector=-1;
+
+ if (ix<=0)
+ {
+ if (iy<=72)
+ {
+ if (iy>24)
+ sector=0;
+ }
+ if (iy<=24)
+ {
+ if (iy>-24)
+ sector=2;
+ }
+ if (iy<=-24)
+ {
+ if (iy>-72)
+ sector=4;
+ }
+ }
+ if (ix>0)
+ {
+ if (iy<=72)
+ {
+ if (iy>24)
+ sector=1;
+ }
+ if (iy<=24)
+ {
+ if (iy>-24)
+ sector=3;
+ }
+ if (iy<=-24)
+ {
+ if (iy>-72)
+ sector=5;
+ }
+ }
+
+
+ if (sector==0)
+ {
+ //x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)-fDpx/2.;
+ //y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)-fDpy/2.;
+ x = Float_t(ix*fDpx)-fDpx/2.-1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.+2.6;
+ }
+ if (sector==1)
+ {
+ x = Float_t(ix*fDpx)-fDpx/2.+1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.+2.6;
+ }
+ if (sector==2)
+ {
+ x = Float_t(ix*fDpx)-fDpx/2.-1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.;
+ }
+ if (sector==3)
+ {
+ x = Float_t(ix*fDpx)-fDpx/2.+1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.;
+ }
+ if (sector==4)
+ {
+ x = Float_t(ix*fDpx)-fDpx/2.-1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.-2.6;
+ }
+ if (sector==5)
+ {
+ x = Float_t(ix*fDpx)-fDpx/2.+1.3;
+ y = Float_t(iy*fDpy)-fDpy/2.-2.6;
+ }
+
+ //if (sector==2)
+ //printf("fSector:%d x:%f y:%f\n",fSector,x,y);
+
+}
+
+void AliRICHSegmentationV1::
+IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
+{
+
+// Calculates integration limits
+
+/*
+ x1=fxt-fx-fDpx/2.;
+ x2=x1+fDpx;
+ y1=fyt-fy-fDpy/2.;
+ y2=y1+fDpy;
+*/
+ //Int_t sector=Sector(fx,fy);
+
+ //printf("Sector:%d\n",sector);
+
+ x1=fxhit-fx-fDpx/2.;
+ x2=x1+fDpx;
+ y1=fyhit-fy-fDpy/2.;
+ y2=y1+fDpy;
+}
--- /dev/null
+#ifndef ALIRICHSEGMENTATIONV1_H
+#define ALIRICHSEGMENTATIONV1_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+#include "AliRICHSegmentationV0.h"
+
+class AliRICHSegmentationV1 : public AliRICHSegmentationV0 {
+
+ public:
+ AliRICHSegmentationV1();
+ virtual ~AliRICHSegmentationV1();
+ // current sector
+ virtual Int_t ISector(){return fSector;}
+ // calculate sector from x-y coordinates
+ virtual Int_t Sector(Float_t x, Float_t y);
+
+ // Transform from pad to real coordinates
+ virtual void GetPadIxy(Float_t x ,Float_t y ,Int_t &ix,Int_t &iy);
+ // Transform from real to pad coordinates
+ virtual void GetPadCxy(Int_t ix,Int_t iy,Float_t &x ,Float_t &y );
+ // Current integration limits
+ virtual void IntegrationLimits
+ (Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2);
+ private:
+ Int_t fSector; //Pad plane sector
+ ClassDef(AliRICHSegmentationV1,1)
+};
+
+#endif
+
+
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * 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$
+*/
+
+
+#include "AliRICHTransientDigit.h"
+#include <TObjArray.h>
+
+ClassImp(AliRICHTransientDigit)
+
+//____________________________________________________________________________
+AliRICHTransientDigit::AliRICHTransientDigit(Int_t ich, Int_t *digits):
+ AliRICHDigit(digits)
+{
+ //
+ // Creates a RICH digit list object
+ //
+
+ fChamber = ich;
+ fTrackList = new TObjArray;
+
+}
+//_____________________________________________________________________________
+
--- /dev/null
+#ifndef ALIRICHTRANSIENTDIGIT_H
+#define ALIRICHTRANSIENTDIGIT_H
+
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id $ */
+#include "AliRICHDigit.h"
+
+class AliRICHTransientDigit : public AliRICHDigit {
+ public:
+ Int_t fRpad; // r_pos of pad
+ Int_t fChamber; // chamber number of pad
+ TObjArray *fTrackList; // list of tracks
+ public:
+ AliRICHTransientDigit() {fTrackList=0;}
+ AliRICHTransientDigit(Int_t ich, Int_t *digits);
+ virtual ~AliRICHTransientDigit() {}
+
+ TObjArray *TrackList() {return fTrackList;}
+
+ ClassDef(AliRICHTransientDigit,1) //Digits for set:RICH
+};
+
+#endif
/*
$Log$
+ Revision 1.10 2000/06/09 14:59:25 jbarbosa
+ New default version. No setters needed, no hits.
+
Revision 1.9 2000/05/31 08:19:38 jbarbosa
Fixed bug in StepManager
#include <TRandom.h>
#include "AliRICHv0.h"
-#include "AliRICHSegResV0.h"
+#include "AliRICHSegmentation.h"
+#include "AliRICHResponse.h"
+#include "AliRICHSegmentationV0.h"
+#include "AliRICHResponseV0.h"
+#include "AliRICHGeometry.h"
#include "AliRun.h"
#include "AliMC.h"
#include "iostream.h"
//___________________________________________
AliRICHv0::AliRICHv0() : AliRICH()
{
+
+// Default constructor
+
//fChambers = 0;
}
{
//
// Version 0
-// Default Segmentation
- AliRICHSegmentationV0* SegmentationV0 = new AliRICHSegmentationV0;
+// Default Segmentation, no hits
+ AliRICHSegmentationV0* segmentationV0 = new AliRICHSegmentationV0;
//
// Segmentation parameters
- SegmentationV0->SetPadSize(0.84,0.80);
- SegmentationV0->SetDAnod(0.84/2);
+ segmentationV0->SetPadSize(0.84,0.80);
+ segmentationV0->SetDAnod(0.84/2);
//
// Geometry parameters
- AliRICHGeometry* GeometryV0 = new AliRICHGeometryV0;
- GeometryV0->SetGapThickness(8);
- GeometryV0->SetProximityGapThickness(.4);
- GeometryV0->SetQuartzLength(131);
- GeometryV0->SetQuartzWidth(126.2);
- GeometryV0->SetQuartzThickness(.5);
- GeometryV0->SetOuterFreonLength(131);
- GeometryV0->SetOuterFreonWidth(40.3);
- GeometryV0->SetInnerFreonLength(131);
- GeometryV0->SetInnerFreonWidth(40.3);
- GeometryV0->SetFreonThickness(1);
+ AliRICHGeometry* geometry = new AliRICHGeometry;
+ geometry->SetGapThickness(8);
+ geometry->SetProximityGapThickness(.4);
+ geometry->SetQuartzLength(131);
+ geometry->SetQuartzWidth(126.2);
+ geometry->SetQuartzThickness(.5);
+ geometry->SetOuterFreonLength(131);
+ geometry->SetOuterFreonWidth(40.3);
+ geometry->SetInnerFreonLength(131);
+ geometry->SetInnerFreonWidth(40.3);
+ geometry->SetFreonThickness(1);
//
// Response parameters
- AliRICHResponseV0* Rresponse0 = new AliRICHResponseV0;
- Rresponse0->SetSigmaIntegration(5.);
- Rresponse0->SetChargeSlope(40.);
- Rresponse0->SetChargeSpread(0.18, 0.18);
- Rresponse0->SetMaxAdc(1024);
- Rresponse0->SetAlphaFeedback(0.05);
- Rresponse0->SetEIonisation(26.e-9);
- Rresponse0->SetSqrtKx3(0.77459667);
- Rresponse0->SetKx2(0.962);
- Rresponse0->SetKx4(0.379);
- Rresponse0->SetSqrtKy3(0.77459667);
- Rresponse0->SetKy2(0.962);
- Rresponse0->SetKy4(0.379);
- Rresponse0->SetPitch(0.25);
+ AliRICHResponseV0* responseV0 = new AliRICHResponseV0;
+ responseV0->SetSigmaIntegration(5.);
+ responseV0->SetChargeSlope(40.);
+ responseV0->SetChargeSpread(0.18, 0.18);
+ responseV0->SetMaxAdc(1024);
+ responseV0->SetAlphaFeedback(0.05);
+ responseV0->SetEIonisation(26.e-9);
+ responseV0->SetSqrtKx3(0.77459667);
+ responseV0->SetKx2(0.962);
+ responseV0->SetKx4(0.379);
+ responseV0->SetSqrtKy3(0.77459667);
+ responseV0->SetKy2(0.962);
+ responseV0->SetKy4(0.379);
+ responseV0->SetPitch(0.25);
//
//
// AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
- fCkov_number=0;
- fFreon_prod=0;
+ fCkovNumber=0;
+ fFreonProd=0;
- fChambers = new TObjArray(7);
- for (Int_t i=0; i<7; i++) {
+ fChambers = new TObjArray(kNCH);
+ for (Int_t i=0; i<kNCH; i++) {
(*fChambers)[i] = new AliRICHChamber();
}
- for (Int_t i=0; i<7; i++) {
- SetGeometryModel(i,GeometryV0);
- SetSegmentationModel(i, SegmentationV0);
- SetResponseModel(i, Rresponse0);
+ for (Int_t i=0; i<kNCH; i++) {
+ SetGeometryModel(i,geometry);
+ SetSegmentationModel(i, segmentationV0);
+ SetResponseModel(i, responseV0);
SetNsec(i,1);
}
}
*/
//End_Html
- AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
+ AliRICH *pRICH = (AliRICH *) gAlice->GetDetector("RICH");
AliRICHSegmentation* segmentation;
AliRICHGeometry* geometry;
AliRICHChamber* iChamber;
- iChamber = &(RICH->Chamber(0));
+ iChamber = &(pRICH->Chamber(0));
segmentation=iChamber->GetSegmentationModel(0);
geometry=iChamber->GetGeometryModel();
// R.A. Fini (INFN - BARI, Rosanna.Fini@ba.infn.it)
// R.A. Loconsole (Bari University, loco@riscom.ba.infn.it)
//
- Int_t ISXFLD = gAlice->Field()->Integ();
- Float_t SXMGMX = gAlice->Field()->Max();
+ Int_t isxfld = gAlice->Field()->Integ();
+ Float_t sxmgmx = gAlice->Field()->Max();
Int_t i;
/************************************Antonnelo's Values (14-vectors)*****************************************/
/*
Float_t ppckov[14] = { 5.63e-9,5.77e-9,5.9e-9,6.05e-9,6.2e-9,6.36e-9,6.52e-9,
6.7e-9,6.88e-9,7.08e-9,7.3e-9,7.51e-9,7.74e-9,8e-9 };
- Float_t rindex_quarz[14] = { 1.528309,1.533333,
+ Float_t rIndexQuarz[14] = { 1.528309,1.533333,
1.538243,1.544223,1.550568,1.55777,
1.565463,1.574765,1.584831,1.597027,
1.611858,1.6277,1.6472,1.6724 };
- Float_t rindex_quarzo[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
- Float_t rindex_methane[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
- Float_t rindex_gri[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
- Float_t absco_freon[14] = { 179.0987,179.0987,
+ Float_t rIndexOpaqueQuarz[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
+ Float_t rIndexMethane[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
+ Float_t rIndexGrid[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
+ Float_t abscoFreon[14] = { 179.0987,179.0987,
179.0987,179.0987,179.0987,142.92,56.65,13.95,10.43,7.07,2.03,.5773,.33496,0. };
- //Float_t absco_freon[14] = { 1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,
+ //Float_t abscoFreon[14] = { 1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,
// 1e-5,1e-5,1e-5,1e-5,1e-5 };
- Float_t absco_quarz[14] = { 64.035,39.98,35.665,31.262,27.527,22.815,21.04,17.52,
+ Float_t abscoQuarz[14] = { 64.035,39.98,35.665,31.262,27.527,22.815,21.04,17.52,
14.177,9.282,4.0925,1.149,.3627,.10857 };
- Float_t absco_quarzo[14] = { 1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,
+ Float_t abscoOpaqueQuarz[14] = { 1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,1e-5,
1e-5,1e-5,1e-5,1e-5,1e-5 };
- Float_t absco_csi[14] = { 1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,
+ Float_t abscoCsI[14] = { 1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,
1e-4,1e-4,1e-4,1e-4 };
- Float_t absco_methane[14] = { 1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,
+ Float_t abscoMethane[14] = { 1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,1e6,
1e6,1e6,1e6 };
- Float_t absco_gri[14] = { 1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,
+ Float_t abscoGrid[14] = { 1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,1e-4,
1e-4,1e-4,1e-4,1e-4 };
- Float_t effic_all[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
- Float_t effic_csi[14] = { 6e-4,.005,.0075,.01125,.045,.117,.135,.16575,
+ Float_t efficAll[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
+ Float_t efficCsI[14] = { 6e-4,.005,.0075,.01125,.045,.117,.135,.16575,
.17425,.1785,.1836,.1904,.1938,.221 };
- Float_t effic_gri[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
+ Float_t efficGrid[14] = { 1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1.,1. };
*/
//Refraction index for quarz
- Float_t rindex_quarz[26];
+ Float_t rIndexQuarz[26];
Float_t e1= 10.666;
Float_t e2= 18.125;
Float_t f1= 46.411;
Float_t ene=ppckov[i]*1e9;
Float_t a=f1/(e1*e1 - ene*ene);
Float_t b=f2/(e2*e2 - ene*ene);
- rindex_quarz[i] = TMath::Sqrt(1. + a + b );
- //printf ("Rindex_quarz: %e\n",rindex_quarz[i]);
+ rIndexQuarz[i] = TMath::Sqrt(1. + a + b );
+ //printf ("rIndexQuarz: %e\n",rIndexQuarz[i]);
}
//Refraction index for opaque quarz, methane and grid
- Float_t rindex_quarzo[26];
- Float_t rindex_methane[26];
- Float_t rindex_gri[26];
+ Float_t rIndexOpaqueQuarz[26];
+ Float_t rIndexMethane[26];
+ Float_t rIndexGrid[26];
for (i=0;i<26;i++)
{
- rindex_quarzo[i]=1;
- rindex_methane[i]=1.000444;
- rindex_gri[i]=1;
- //printf ("Rindex_quarzo , etc: %e, %e, %e\n",rindex_quarzo[i], rindex_methane[i], rindex_gri[i]=1);
+ rIndexOpaqueQuarz[i]=1;
+ rIndexMethane[i]=1.000444;
+ rIndexGrid[i]=1;
+ //printf ("rIndexOpaqueQuarz , etc: %e, %e, %e\n",rIndexOpaqueQuarz[i], rIndexMethane[i], rIndexGrid[i]=1);
}
//Absorption index for freon
- Float_t absco_freon[26] = {179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987,
+ Float_t abscoFreon[26] = {179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987, 179.0987,
179.0987, 142.9206, 56.64957, 25.58622, 13.95293, 12.03905, 10.42953, 8.804196,
7.069031, 4.461292, 2.028366, 1.293013, .577267, .40746, .334964, 0., 0., 0.};
.906,.907,.907,.907};
Float_t Wavl2[] = {150.,155.,160.0,165.0,170.0,175.0,180.0,185.0,190.0,195.0,200.0,205.0,210.0,
215.0,220.0,225.0,230.0,235.0,240.0,245.0,250.0};
- Float_t absco_quarz[31];
+ Float_t abscoQuarz[31];
for (Int_t i=0;i<31;i++)
{
Float_t Xlam = 1237.79 / (ppckov[i]*1e9);
- if (Xlam <= 160) absco_quarz[i] = 0;
- if (Xlam > 250) absco_quarz[i] = 1;
+ if (Xlam <= 160) abscoQuarz[i] = 0;
+ if (Xlam > 250) abscoQuarz[i] = 1;
else
{
for (Int_t j=0;j<21;j++)
{
Float_t Dabs = (Qzt[j+1] - Qzt[j])/(Wavl2[j+1] - Wavl2[j]);
Float_t Abso = Qzt[j] + Dabs*(Xlam - Wavl2[j]);
- absco_quarz[i] = -5.0/(TMath::Log(Abso));
+ abscoQuarz[i] = -5.0/(TMath::Log(Abso));
}
}
}
- printf ("Absco_quarz: %e Absco_freon: %e for energy: %e\n",absco_quarz[i],absco_freon[i],ppckov[i]);
+ printf ("abscoQuarz: %e abscoFreon: %e for energy: %e\n",abscoQuarz[i],abscoFreon[i],ppckov[i]);
}*/
- /*Float_t absco_quarz[31] = {49.64211, 48.41296, 47.46989, 46.50492, 45.13682, 44.47883, 43.1929 , 41.30922, 40.5943 ,
+ /*Float_t abscoQuarz[31] = {49.64211, 48.41296, 47.46989, 46.50492, 45.13682, 44.47883, 43.1929 , 41.30922, 40.5943 ,
39.82956, 38.98623, 38.6247 , 38.43448, 37.41084, 36.22575, 33.74852, 30.73901, 24.25086,
17.94531, 11.88753, 5.99128, 3.83503, 2.36661, 1.53155, 1.30582, 1.08574, .8779708,
.675275, 0., 0., 0.};
for (Int_t i=0;i<31;i++)
{
- absco_quarz[i] = absco_quarz[i]/10;
+ abscoQuarz[i] = abscoQuarz[i]/10;
}*/
- Float_t absco_quarz [26] = {105.8, 65.52, 48.58, 42.85, 35.79, 31.262, 28.598, 27.527, 25.007, 22.815, 21.004,
+ Float_t abscoQuarz [26] = {105.8, 65.52, 48.58, 42.85, 35.79, 31.262, 28.598, 27.527, 25.007, 22.815, 21.004,
19.266, 17.525, 15.878, 14.177, 11.719, 9.282, 6.62, 4.0925, 2.601, 1.149, .667, .3627,
.192, .1497, .10857};
//Absorption index for methane
- Float_t absco_methane[26];
+ Float_t abscoMethane[26];
for (i=0;i<26;i++)
{
- absco_methane[i]=AbsoCH4(ppckov[i]*1e9);
- //printf("Absco_methane: %e for energy: %e\n", absco_methane[i],ppckov[i]*1e9);
+ abscoMethane[i]=AbsoCH4(ppckov[i]*1e9);
+ //printf("abscoMethane: %e for energy: %e\n", abscoMethane[i],ppckov[i]*1e9);
}
//Absorption index for opaque quarz, csi and grid, efficiency for all and grid
- Float_t absco_quarzo[26];
- Float_t absco_csi[26];
- Float_t absco_gri[26];
- Float_t effic_all[26];
- Float_t effic_gri[26];
+ Float_t abscoOpaqueQuarz[26];
+ Float_t abscoCsI[26];
+ Float_t abscoGrid[26];
+ Float_t efficAll[26];
+ Float_t efficGrid[26];
for (i=0;i<26;i++)
{
- absco_quarzo[i]=1e-5;
- absco_csi[i]=1e-4;
- absco_gri[i]=1e-4;
- effic_all[i]=1;
- effic_gri[i]=1;
- //printf ("All must be 1: %e, %e, %e, %e, %e\n",absco_quarzo[i],absco_csi[i],absco_gri[i],effic_all[i],effic_gri[i]);
+ abscoOpaqueQuarz[i]=1e-5;
+ abscoCsI[i]=1e-4;
+ abscoGrid[i]=1e-4;
+ efficAll[i]=1;
+ efficGrid[i]=1;
+ //printf ("All must be 1: %e, %e, %e, %e, %e\n",abscoOpaqueQuarz[i],abscoCsI[i],abscoGrid[i],efficAll[i],efficGrid[i]);
}
//Efficiency for csi
- Float_t effic_csi[26] = {0.000199999995, 0.000600000028, 0.000699999975, 0.00499999989, 0.00749999983, 0.010125,
+ Float_t efficCsI[26] = {0.000199999995, 0.000600000028, 0.000699999975, 0.00499999989, 0.00749999983, 0.010125,
0.0242999997, 0.0405000001, 0.0688500032, 0.105299994, 0.121500008, 0.141749993, 0.157949999,
0.162, 0.166050002, 0.167669997, 0.174299985, 0.176789999, 0.179279998, 0.182599992, 0.18592,
0.187579989, 0.189239994, 0.190899998, 0.207499996, 0.215799987};
for (i=0;i<26;i++)
{
- effic_csi[i] = effic_csi[i]/(1.-Fresnel(ppckov[i]*1e9,1.,0));
+ efficCsI[i] = efficCsI[i]/(1.-Fresnel(ppckov[i]*1e9,1.,0));
//printf ("Fresnel result: %e for energy: %e\n",Fresnel(ppckov[i]*1e9,1.,0),ppckov[i]*1e9);
}
Int_t nlmatfre;
Float_t densquao;
Int_t nlmatmet, nlmatqua;
- Float_t wmatquao[2], rindex_freon[26];
+ Float_t wmatquao[2], rIndexFreon[26];
Float_t aquao[2], epsil, stmin, zquao[2];
Int_t nlmatquao;
Float_t radlal, densal, tmaxfd, deemax, stemax;
// --- Photon energy (GeV)
// --- Refraction indexes
for (i = 0; i < 26; ++i) {
- rindex_freon[i] = ppckov[i] * .0172 * 1e9 + 1.177;
- //printf ("Rindex_freon: %e \n Effic_csi: %e for energy: %e\n",rindex_freon[i], effic_csi[i], ppckov[i]);
+ rIndexFreon[i] = ppckov[i] * .0172 * 1e9 + 1.177;
+ //printf ("rIndexFreon: %e \n efficCsI: %e for energy: %e\n",rIndexFreon[i], efficCsI[i], ppckov[i]);
}
// --- Detection efficiencies (quantum efficiency for CsI)
epsil = .001;
stmin = -.001;
- AliMedium(1, "DEFAULT MEDIUM AIR$", 1, 0, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(2, "HONEYCOMB$", 6, 0, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(3, "QUARZO$", 20, 1, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(4, "FREON$", 30, 1, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(5, "METANO$", 40, 1, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(6, "CSI$", 16, 1, ISXFLD, SXMGMX,tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(7, "GRIGLIA$", 11, 0, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(8, "QUARZOO$", 21, 1, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
- AliMedium(9, "GAP$", 41, 1, ISXFLD, SXMGMX,tmaxfd, .1, -deemax, epsil, -stmin);
- AliMedium(10, "ALUMINUM$", 50, 1, ISXFLD, SXMGMX, tmaxfd, stemax, deemax, epsil, stmin);
-
-
- geant3->Gsckov(idtmed[1000], 26, ppckov, absco_methane, effic_all, rindex_methane);
- geant3->Gsckov(idtmed[1001], 26, ppckov, absco_methane, effic_all, rindex_methane);
- geant3->Gsckov(idtmed[1002], 26, ppckov, absco_quarz, effic_all,rindex_quarz);
- geant3->Gsckov(idtmed[1003], 26, ppckov, absco_freon, effic_all,rindex_freon);
- geant3->Gsckov(idtmed[1004], 26, ppckov, absco_methane, effic_all, rindex_methane);
- geant3->Gsckov(idtmed[1005], 26, ppckov, absco_csi, effic_csi, rindex_methane);
- geant3->Gsckov(idtmed[1006], 26, ppckov, absco_gri, effic_gri, rindex_gri);
- geant3->Gsckov(idtmed[1007], 26, ppckov, absco_quarzo, effic_all, rindex_quarzo);
- geant3->Gsckov(idtmed[1008], 26, ppckov, absco_methane, effic_all, rindex_methane);
- geant3->Gsckov(idtmed[1009], 26, ppckov, absco_gri, effic_gri, rindex_gri);
+ AliMedium(1, "DEFAULT MEDIUM AIR$", 1, 0, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(2, "HONEYCOMB$", 6, 0, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(3, "QUARZO$", 20, 1, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(4, "FREON$", 30, 1, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(5, "METANO$", 40, 1, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(6, "CSI$", 16, 1, isxfld, sxmgmx,tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(7, "GRIGLIA$", 11, 0, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(8, "QUARZOO$", 21, 1, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+ AliMedium(9, "GAP$", 41, 1, isxfld, sxmgmx,tmaxfd, .1, -deemax, epsil, -stmin);
+ AliMedium(10, "ALUMINUM$", 50, 1, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+
+
+ geant3->Gsckov(idtmed[1000], 26, ppckov, abscoMethane, efficAll, rIndexMethane);
+ geant3->Gsckov(idtmed[1001], 26, ppckov, abscoMethane, efficAll, rIndexMethane);
+ geant3->Gsckov(idtmed[1002], 26, ppckov, abscoQuarz, efficAll,rIndexQuarz);
+ geant3->Gsckov(idtmed[1003], 26, ppckov, abscoFreon, efficAll,rIndexFreon);
+ geant3->Gsckov(idtmed[1004], 26, ppckov, abscoMethane, efficAll, rIndexMethane);
+ geant3->Gsckov(idtmed[1005], 26, ppckov, abscoCsI, efficCsI, rIndexMethane);
+ geant3->Gsckov(idtmed[1006], 26, ppckov, abscoGrid, efficGrid, rIndexGrid);
+ geant3->Gsckov(idtmed[1007], 26, ppckov, abscoOpaqueQuarz, efficAll, rIndexOpaqueQuarz);
+ geant3->Gsckov(idtmed[1008], 26, ppckov, abscoMethane, efficAll, rIndexMethane);
+ geant3->Gsckov(idtmed[1009], 26, ppckov, abscoGrid, efficGrid, rIndexGrid);
}
//___________________________________________
Float_t AliRICHv0::AbsoCH4(Float_t x)
{
- //LOSCH,SCH4(9),WL(9),EM(9),ALENGTH(31)
+ //KLOSCH,SCH4(9),WL(9),EM(9),ALENGTH(31)
Float_t sch4[9] = {.12,.16,.23,.38,.86,2.8,7.9,28.,80.}; //MB X 10^22
//Float_t wl[9] = {153.,152.,151.,150.,149.,148.,147.,146.,145};
Float_t em[9] = {8.1,8.158,8.212,8.267,8.322,8.378,8.435,8.493,8.55};
- const Float_t losch=2.686763E19; // LOSCHMIDT NUMBER IN CM-3
- const Float_t igas1=100, igas2=0, oxy=10., wat=5., pre=750.,tem=283.;
- Float_t pn=pre/760.;
- Float_t tn=tem/273.16;
+ const Float_t kLosch=2.686763E19; // LOSCHMIDT NUMBER IN CM-3
+ const Float_t kIgas1=100, kIgas2=0, kOxy=10., kWater=5., kPressure=750.,kTemperature=283.;
+ Float_t pn=kPressure/760.;
+ Float_t tn=kTemperature/273.16;
// ------- METHANE CROSS SECTION -----------------
}
}
- Float_t dm=(igas1/100.)*(1.-((oxy+wat)/1.e6))*losch*pn/tn;
+ Float_t dm=(kIgas1/100.)*(1.-((kOxy+kWater)/1.e6))*kLosch*pn/tn;
Float_t abslm=1./sm/dm;
// ------- ISOBUTHANE CROSS SECTION --------------
Float_t ai;
Float_t absli;
- if (igas2 != 0)
+ if (kIgas2 != 0)
{
if (x<7.25)
ai=100000000.;
if(x>=7.375)
ai=.0000000001;
- Float_t si = 1./(ai*losch*273.16/293.); // ISOB. CRO.SEC.IN CM2
- Float_t di=(igas2/100.)*(1.-((oxy+wat)/1.e6))*losch*pn/tn;
+ Float_t si = 1./(ai*kLosch*273.16/293.); // ISOB. CRO.SEC.IN CM2
+ Float_t di=(kIgas2/100.)*(1.-((kOxy+kWater)/1.e6))*kLosch*pn/tn;
absli =1./si/di;
}
else
so=so*1e-18;
}
- Float_t dox=(oxy/1e6)*losch*pn/tn;
+ Float_t dox=(kOxy/1e6)*kLosch*pn/tn;
abslo=1./so/dox;
}
else
{
Float_t sw= b0+(b1*x)+(b2*x*x)+(b3*x*x*x)+(b4*x*x*x*x);
sw=sw*1e-18;
- Float_t dw=(wat/1e6)*losch*pn/tn;
+ Float_t dw=(kWater/1e6)*kLosch*pn/tn;
abslw=1./sw/dw;
}
else
//
// Initialize Tracking Chambers
//
- for (Int_t i=1; i<7; i++) {
+ for (Int_t i=1; i<kNCH; i++) {
//printf ("i:%d",i);
( (AliRICHChamber*) (*fChambers)[i])->Init();
}
//___________________________________________
-Int_t AliRICH::MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss, Int_t idvol, Response_t res)
-{
-//
-// Calls the charge disintegration method of the current chamber and adds
-// the simulated cluster to the root treee
-//
- Int_t clhits[7];
- Float_t newclust[6][500];
- Int_t nnew;
-
-//
-// Integrated pulse height on chamber
-
- clhits[0]=fNhits+1;
-
- ((AliRICHChamber*) (*fChambers)[idvol])->DisIntegration(eloss, xhit, yhit, nnew, newclust, res);
- Int_t ic=0;
-
-//
-// Add new clusters
- for (Int_t i=0; i<nnew; i++) {
- if (Int_t(newclust[3][i]) > 0) {
- ic++;
-// Cathode plane
- clhits[1] = Int_t(newclust[5][i]);
-// Cluster Charge
- clhits[2] = Int_t(newclust[0][i]);
-// Pad: ix
- clhits[3] = Int_t(newclust[1][i]);
-// Pad: iy
- clhits[4] = Int_t(newclust[2][i]);
-// Pad: charge
- clhits[5] = Int_t(newclust[3][i]);
-// Pad: chamber sector
- clhits[6] = Int_t(newclust[4][i]);
-
- AddPadHit(clhits);
- }
- }
-return nnew;
-}
-#ifndef RICHv0_H
-#define RICHv0_H
+#ifndef ALIRICHV0_H
+#define ALIRICHV0_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
class AliRICHv0 : public AliRICH {
public:
- Int_t fCkov_number;
- Int_t fCkov_quarz;
- Int_t fCkov_gap;
- Int_t fCkov_csi;
- Int_t fLost_rfreo;
- Int_t fLost_rquar;
- Int_t fLost_afreo;
- Int_t fLost_aquarz;
- Int_t fLost_ameta;
- Int_t fLost_csi;
- Int_t fLost_wires;
- Int_t fFreon_prod;
- Float_t fMipx;
- Float_t fMipy;
- Int_t fFeedbacks;
- Int_t fLost_fresnel;
-
AliRICHv0();
AliRICHv0(const char *name, const char *title);
virtual ~AliRICHv0() {}
Float_t Fresnel(Float_t ene,Float_t pdoti, Bool_t pola);
Float_t AbsoCH4(Float_t x);
// virtual void Trigger(Float_t (*)[4], Float_t (*)[4], Int_t& iflag);
- private:
+ protected:
+ Int_t fCkovNumber; // Number of Cerenkov photons
+ Int_t fCkovQuarz; // Cerenkovs crossing quartz
+ Int_t fCkovGap; // Cerenkovs crossing gap
+ Int_t fCkovCsi; // Cerenkovs crossing csi
+ Int_t fLostRfreo; // Cerenkovs reflected in freon
+ Int_t fLostRquar; // Cerenkovs reflected in quartz
+ Int_t fLostAfreo; // Cerenkovs absorbed in freon
+ Int_t fLostAquarz; // Cerenkovs absorbed in quartz
+ Int_t fLostAmeta; // Cerenkovs absorbed in methane
+ Int_t fLostCsi; // Cerenkovs below csi quantum efficiency
+ Int_t fLostWires; // Cerenkovs lost in wires
+ Int_t fFreonProd; // Cerenkovs produced in freon
+ Float_t fMipx; // x coord. of MIP
+ Float_t fMipy; // y coord. of MIP
+ Int_t fFeedbacks; // Number of feedback photons
+ Int_t fLostFresnel; // Cerenkovs lost by Fresnel reflection
ClassDef(AliRICHv0,1) //Hits manager for set: RICH default version
};
/*
$Log$
+ Revision 1.1 2000/06/09 15:00:31 jbarbosa
+ New full version. All parameters configurable.
+
Revision 1.9 2000/05/31 08:19:38 jbarbosa
Fixed bug in StepManager
#include <TTUBE.h>
#include <TNode.h>
#include <TRandom.h>
+#include <TParticle.h>
#include "AliRICHv1.h"
+#include "AliRICHHit.h"
#include "AliRun.h"
#include "AliMC.h"
#include "iostream.h"
//___________________________________________
AliRICHv1::AliRICHv1() : AliRICHv0()
{
+
+// Default constructor fo AliRICHvv1 (full version)
+
//fChambers = 0;
}
AliRICHv1::AliRICHv1(const char *name, const char *title)
: AliRICHv0(name,title)
{
- fCkov_number=0;
- fFreon_prod=0;
- fChambers = new TObjArray(7);
- for (Int_t i=0; i<7; i++) {
+// Full version of RICH with hits and diagnostics
+
+ fCkovNumber=0;
+ fFreonProd=0;
+
+ fChambers = new TObjArray(kNCH);
+ for (Int_t i=0; i<kNCH; i++) {
(*fChambers)[i] = new AliRICHChamber();
}
}
+void AliRICHv1::Init()
+{
+
+ printf("*********************************** RICH_INIT ***********************************\n");
+ printf("* *\n");
+ printf("* AliRICHv1 Configurable version started *\n");
+ printf("* *\n");
+
+
+ AliRICHSegmentation* segmentation;
+ AliRICHGeometry* geometry;
+ AliRICHResponse* response;
+
+
+ //
+ // Initialize Tracking Chambers
+ //
+ for (Int_t i=1; i<kNCH; i++) {
+ //printf ("i:%d",i);
+ ( (AliRICHChamber*) (*fChambers)[i])->Init();
+ }
+
+ //
+ // Set the chamber (sensitive region) GEANT identifier
+
+ ((AliRICHChamber*)(*fChambers)[0])->SetGid(1);
+ ((AliRICHChamber*)(*fChambers)[1])->SetGid(2);
+ ((AliRICHChamber*)(*fChambers)[2])->SetGid(3);
+ ((AliRICHChamber*)(*fChambers)[3])->SetGid(4);
+ ((AliRICHChamber*)(*fChambers)[4])->SetGid(5);
+ ((AliRICHChamber*)(*fChambers)[5])->SetGid(6);
+ ((AliRICHChamber*)(*fChambers)[6])->SetGid(7);
+
+ Float_t pos1[3]={0,471.8999,165.2599};
+ Chamber(0).SetChamberTransform(pos1[0],pos1[1],pos1[2],new TRotMatrix("rot993","rot993",90,0,70.69,90,19.30999,-90));
+
+ Float_t pos2[3]={171,470,0};
+ Chamber(1).SetChamberTransform(pos2[0],pos2[1],pos2[2],new TRotMatrix("rot994","rot994",90,-20,90,70,0,0));
+
+ Float_t pos3[3]={0,500,0};
+ Chamber(2).SetChamberTransform(pos3[0],pos3[1],pos3[2],new TRotMatrix("rot995","rot995",90,0,90,90,0,0));
+
+ Float_t pos4[3]={-171,470,0};
+ Chamber(3).SetChamberTransform(pos4[0],pos4[1],pos4[2], new TRotMatrix("rot996","rot996",90,20,90,110,0,0));
+
+ Float_t pos5[3]={161.3999,443.3999,-165.3};
+ Chamber(4).SetChamberTransform(pos5[0],pos5[1],pos5[2],new TRotMatrix("rot997","rot997",90,340,108.1999,70,18.2,70));
+
+ Float_t pos6[3]={0., 471.9, -165.3,};
+ Chamber(5).SetChamberTransform(pos6[0],pos6[1],pos6[2],new TRotMatrix("rot998","rot998",90,0,109.3099,90,19.30999,90));
+
+ Float_t pos7[3]={-161.399,443.3999,-165.3};
+ Chamber(6).SetChamberTransform(pos7[0],pos7[1],pos7[2],new TRotMatrix("rot999","rot999",90,20,108.1999,110,18.2,110));
+
+ segmentation=Chamber(0).GetSegmentationModel(0);
+ geometry=Chamber(0).GetGeometryModel();
+ response=Chamber(0).GetResponseModel();
+
+
+ printf("* Pads : %3dx%3d *\n",segmentation->Npx(),segmentation->Npy());
+ printf("* Pad size : %5.2f x%5.2f mm2 *\n",segmentation->Dpx(),segmentation->Dpy());
+ printf("* Gap Thickness : %5.1f mm *\n",geometry->GetGapThickness());
+ printf("* Radiator Width : %5.1f mm *\n",geometry->GetQuartzWidth());
+ printf("* Radiator Length : %5.1f mm *\n",geometry->GetQuartzLength());
+ printf("* Freon Thickness : %5.1f mm *\n",geometry->GetFreonThickness());
+ printf("* Charge Slope : %5.1f ADC *\n",response->ChargeSlope());
+ printf("* Feedback Prob. : %5.2f %% *\n",response->AlphaFeedback());
+ printf("* *\n");
+ printf("* Success! *\n");
+ printf("* *\n");
+ printf("*********************************************************************************\n");
+
+}
//___________________________________________
void AliRICHv1::StepManager()
{
+
+// Full Step Manager
+
Int_t copy, id;
static Int_t idvol;
static Int_t vol[2];
Int_t ipart;
static Float_t hits[18];
- static Float_t Ckov_data[19];
- TLorentzVector Position;
- TLorentzVector Momentum;
+ static Float_t ckovData[19];
+ TLorentzVector position;
+ TLorentzVector momentum;
Float_t pos[3];
Float_t mom[4];
- Float_t Localpos[3];
- Float_t Localmom[4];
- Float_t Localtheta,Localphi;
+ Float_t localPos[3];
+ Float_t localMom[4];
+ Float_t localTheta,localPhi;
Float_t theta,phi;
Float_t destep, step;
Float_t ranf[2];
- Int_t NPads;
+ Int_t nPads;
Float_t coscerenkov;
static Float_t eloss, xhit, yhit, tlength;
- const Float_t big=1.e10;
+ const Float_t kBig=1.e10;
TClonesArray &lhits = *fHits;
TGeant3 *geant3 = (TGeant3*) gMC;
idvol=-1;
id=gMC->CurrentVolID(copy);
- Float_t cherenkov_loss=0;
+ Float_t cherenkovLoss=0;
//gAlice->KeepTrack(gAlice->CurrentTrack());
- gMC->TrackPosition(Position);
- pos[0]=Position(0);
- pos[1]=Position(1);
- pos[2]=Position(2);
- Ckov_data[1] = pos[0]; // X-position for hit
- Ckov_data[2] = pos[1]; // Y-position for hit
- Ckov_data[3] = pos[2]; // Z-position for hit
- //Ckov_data[11] = gAlice->CurrentTrack();
+ gMC->TrackPosition(position);
+ pos[0]=position(0);
+ pos[1]=position(1);
+ pos[2]=position(2);
+ ckovData[1] = pos[0]; // X-position for hit
+ ckovData[2] = pos[1]; // Y-position for hit
+ ckovData[3] = pos[2]; // Z-position for hit
+ //ckovData[11] = gAlice->CurrentTrack();
//AliRICH *RICH = (AliRICH *) gAlice->GetDetector("RICH");
//if (gMC->VolId("GAP ")==gMC->CurrentVolID(copy))
//{
- Float_t Ckov_energy = current->Energy();
+ Float_t ckovEnergy = current->Energy();
//energy interval for tracking
- if (Ckov_energy > 5.6e-09 && Ckov_energy < 7.8e-09 )
- //if (Ckov_energy > 0)
+ if (ckovEnergy > 5.6e-09 && ckovEnergy < 7.8e-09 )
+ //if (ckovEnergy > 0)
{
if (gMC->IsTrackEntering()){ //is track entering?
if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
//printf("Second Mother:%d\n",current->GetSecondMother());
- Ckov_data[10] = mother;
- Ckov_data[11] = gAlice->CurrentTrack();
- Ckov_data[12] = 1; //Media where photon was produced 1->Freon, 2->Quarz
- fCkov_number++;
- fFreon_prod=1;
- //printf("Index: %d\n",fCkov_number);
+ ckovData[10] = mother;
+ ckovData[11] = gAlice->CurrentTrack();
+ ckovData[12] = 1; //Media where photon was produced 1->Freon, 2->Quarz
+ fCkovNumber++;
+ fFreonProd=1;
+ //printf("Index: %d\n",fCkovNumber);
} //first step question
} //freo question
if (geant3->Gctrak()->nstep<1){ //is it first step?
if (gMC->VolId("QUAR")==gMC->CurrentVolID(copy)) //is it in quarz?
{
- Ckov_data[12] = 2;
+ ckovData[12] = 2;
} //quarz question
} //first step question
- //printf("Before %d\n",fFreon_prod);
+ //printf("Before %d\n",fFreonProd);
} //track entering question
- if (Ckov_data[12] == 1) //was it produced in Freon?
- //if (fFreon_prod == 1)
+ if (ckovData[12] == 1) //was it produced in Freon?
+ //if (fFreonProd == 1)
{
if (gMC->IsTrackEntering()){ //is track entering?
//printf("Got in");
if (gMC->VolId("META")==gMC->CurrentVolID(copy)) //is it in gap?
{
//printf("Got in\n");
- gMC->TrackMomentum(Momentum);
- mom[0]=Momentum(0);
- mom[1]=Momentum(1);
- mom[2]=Momentum(2);
- mom[3]=Momentum(3);
+ gMC->TrackMomentum(momentum);
+ mom[0]=momentum(0);
+ mom[1]=momentum(1);
+ mom[2]=momentum(2);
+ mom[3]=momentum(3);
// Z-position for hit
//printf("grid calculation:%f\n",t);
if (ranf[0] > t) {
//geant3->StopTrack();
- Ckov_data[13] = 5;
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
+ ckovData[13] = 5;
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
//printf("Lost one in grid\n");
}
/**********************************************************************************/
if (gMC->VolId("CSI ")==gMC->CurrentVolID(copy)) //is it in csi?
{
- gMC->TrackMomentum(Momentum);
- mom[0]=Momentum(0);
- mom[1]=Momentum(1);
- mom[2]=Momentum(2);
- mom[3]=Momentum(3);
+ gMC->TrackMomentum(momentum);
+ mom[0]=momentum(0);
+ mom[1]=momentum(1);
+ mom[2]=momentum(2);
+ mom[3]=momentum(3);
/********* Photons lost by Fresnel reflection have to be calculated by hand********/
/***********************Cerenkov phtons (always polarised)*************************/
Float_t cophi = TMath::Cos(TMath::ATan2(mom[0], mom[1]));
- Float_t t = Fresnel(Ckov_energy*1e9,cophi,1);
+ Float_t t = Fresnel(ckovEnergy*1e9,cophi,1);
gMC->Rndm(ranf, 1);
if (ranf[0] < t) {
//geant3->StopTrack();
- Ckov_data[13] = 6;
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
+ ckovData[13] = 6;
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
//printf("Lost by Fresnel\n");
}
/**********************************************************************************/
for (Int_t i = 0; i < i1; ++i) {
// Reflection loss
if (geant3->Gctrak()->lmec[i] == 106) { //was it reflected
- Ckov_data[13]=10;
+ ckovData[13]=10;
if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
- Ckov_data[13]=1;
+ ckovData[13]=1;
if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR"))
- Ckov_data[13]=2;
+ ckovData[13]=2;
//geant3->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
} //reflection question
// Absorption loss
else if (geant3->Gctrak()->lmec[i] == 101) { //was it absorbed?
- Ckov_data[13]=20;
+ ckovData[13]=20;
if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
- Ckov_data[13]=11;
+ ckovData[13]=11;
if (gMC->CurrentVolID(copy) == gMC->VolId("QUAR"))
- Ckov_data[13]=12;
+ ckovData[13]=12;
if (gMC->CurrentVolID(copy) == gMC->VolId("META"))
- Ckov_data[13]=13;
+ ckovData[13]=13;
if (gMC->CurrentVolID(copy) == gMC->VolId("GAP "))
- Ckov_data[13]=13;
+ ckovData[13]=13;
if (gMC->CurrentVolID(copy) == gMC->VolId("SRIC"))
- Ckov_data[13]=15;
+ ckovData[13]=15;
// CsI inefficiency
if (gMC->CurrentVolID(copy) == gMC->VolId("CSI ")) {
- Ckov_data[13]=16;
+ ckovData[13]=16;
}
//geant3->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
- //printf("Added cerenkov %d\n",fCkov_number);
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
+ //printf("Added cerenkov %d\n",fCkovNumber);
} //absorption question
// Photon goes out of tracking scope
else if (geant3->Gctrak()->lmec[i] == 30) { //is it below energy treshold?
- Ckov_data[13]=21;
+ ckovData[13]=21;
//geant3->StopTrack();
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
} // energy treshold question
} //number of mechanisms cycle
/**********************End of evaluation************************/
{
if (gMC->Edep() > 0.){
- gMC->TrackPosition(Position);
- gMC->TrackMomentum(Momentum);
- pos[0]=Position(0);
- pos[1]=Position(1);
- pos[2]=Position(2);
- mom[0]=Momentum(0);
- mom[1]=Momentum(1);
- mom[2]=Momentum(2);
- mom[3]=Momentum(3);
+ gMC->TrackPosition(position);
+ gMC->TrackMomentum(momentum);
+ pos[0]=position(0);
+ pos[1]=position(1);
+ pos[2]=position(2);
+ mom[0]=momentum(0);
+ mom[1]=momentum(1);
+ mom[2]=momentum(2);
+ mom[3]=momentum(3);
Double_t tc = mom[0]*mom[0]+mom[1]*mom[1];
Double_t rt = TMath::Sqrt(tc);
theta = Float_t(TMath::ATan2(rt,Double_t(mom[2])))*kRaddeg;
phi = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
- gMC->Gmtod(pos,Localpos,1);
- gMC->Gmtod(mom,Localmom,2);
+ gMC->Gmtod(pos,localPos,1);
+ gMC->Gmtod(mom,localMom,2);
gMC->CurrentVolOffID(2,copy);
vol[0]=copy;
idvol=vol[0]-1;
//Int_t sector=((AliRICHChamber*) (*fChambers)[idvol])
- //->Sector(Localpos[0], Localpos[2]);
+ //->Sector(localPos[0], localPos[2]);
//printf("Sector:%d\n",sector);
/*if (gMC->TrackPid() == 50000051){
}*/
((AliRICHChamber*) (*fChambers)[idvol])
- ->SigGenInit(Localpos[0], Localpos[2], Localpos[1]);
- if(idvol<7) {
- Ckov_data[0] = gMC->TrackPid(); // particle type
- Ckov_data[1] = pos[0]; // X-position for hit
- Ckov_data[2] = pos[1]; // Y-position for hit
- Ckov_data[3] = pos[2]; // Z-position for hit
- Ckov_data[4] = theta; // theta angle of incidence
- Ckov_data[5] = phi; // phi angle of incidence
- Ckov_data[8] = (Float_t) fNPadHits; // first padhit
- Ckov_data[9] = -1; // last pad hit
- Ckov_data[13] = 4; // photon was detected
- Ckov_data[14] = mom[0];
- Ckov_data[15] = mom[1];
- Ckov_data[16] = mom[2];
+ ->SigGenInit(localPos[0], localPos[2], localPos[1]);
+ if(idvol<kNCH) {
+ ckovData[0] = gMC->TrackPid(); // particle type
+ ckovData[1] = pos[0]; // X-position for hit
+ ckovData[2] = pos[1]; // Y-position for hit
+ ckovData[3] = pos[2]; // Z-position for hit
+ ckovData[4] = theta; // theta angle of incidence
+ ckovData[5] = phi; // phi angle of incidence
+ ckovData[8] = (Float_t) fNPadHits; // first padhit
+ ckovData[9] = -1; // last pad hit
+ ckovData[13] = 4; // photon was detected
+ ckovData[14] = mom[0];
+ ckovData[15] = mom[1];
+ ckovData[16] = mom[2];
destep = gMC->Edep();
- gMC->SetMaxStep(big);
- cherenkov_loss += destep;
- Ckov_data[7]=cherenkov_loss;
+ gMC->SetMaxStep(kBig);
+ cherenkovLoss += destep;
+ ckovData[7]=cherenkovLoss;
- NPads = MakePadHits(Localpos[0],Localpos[2],cherenkov_loss,idvol,cerenkov);
- if (fNPadHits > (Int_t)Ckov_data[8]) {
- Ckov_data[8]= Ckov_data[8]+1;
- Ckov_data[9]= (Float_t) fNPadHits;
+ nPads = MakePadHits(localPos[0],localPos[2],cherenkovLoss,idvol,kCerenkov);
+ if (fNPadHits > (Int_t)ckovData[8]) {
+ ckovData[8]= ckovData[8]+1;
+ ckovData[9]= (Float_t) fNPadHits;
}
- Ckov_data[17] = NPads;
- //printf("Npads:%d",NPads);
+ ckovData[17] = nPads;
+ //printf("nPads:%d",nPads);
//TClonesArray *Hits = RICH->Hits();
AliRICHHit *mipHit = (AliRICHHit*) (fHits->UncheckedAt(0));
mom[0] = current->Px();
mom[1] = current->Py();
mom[2] = current->Pz();
- Float_t Mip_px = mipHit->fMomX;
- Float_t Mip_py = mipHit->fMomY;
- Float_t Mip_pz = mipHit->fMomZ;
+ Float_t mipPx = mipHit->fMomX;
+ Float_t mipPy = mipHit->fMomY;
+ Float_t mipPz = mipHit->fMomZ;
Float_t r = mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2];
Float_t rt = TMath::Sqrt(r);
- Float_t Mip_r = Mip_px*Mip_px + Mip_py*Mip_py + Mip_pz*Mip_pz;
- Float_t Mip_rt = TMath::Sqrt(Mip_r);
- if ((rt*Mip_rt) > 0)
+ Float_t mipR = mipPx*mipPx + mipPy*mipPy + mipPz*mipPz;
+ Float_t mipRt = TMath::Sqrt(mipR);
+ if ((rt*mipRt) > 0)
{
- coscerenkov = (mom[0]*Mip_px + mom[1]*Mip_py + mom[2]*Mip_pz)/(rt*Mip_rt);
+ coscerenkov = (mom[0]*mipPx + mom[1]*mipPy + mom[2]*mipPz)/(rt*mipRt);
}
else
{
coscerenkov = 0;
}
Float_t cherenkov = TMath::ACos(coscerenkov);
- Ckov_data[18]=cherenkov;
+ ckovData[18]=cherenkov;
}
//if (sector != -1)
//{
- AddHit(gAlice->CurrentTrack(),vol,Ckov_data);
- AddCerenkov(gAlice->CurrentTrack(),vol,Ckov_data);
+ AddHit(gAlice->CurrentTrack(),vol,ckovData);
+ AddCerenkov(gAlice->CurrentTrack(),vol,ckovData);
//}
}
}
}*/
if (gMC->VolId("FRE1")==gMC->CurrentVolID(copy) || gMC->VolId("FRE2")==gMC->CurrentVolID(copy))
{
- fFreon_prod=1;
+ fFreonProd=1;
}
if (gMC->VolId("GAP ")== gMC->CurrentVolID(copy)) {
idvol=vol[0]-1;
//Int_t sector=((AliRICHChamber*) (*fChambers)[idvol])
- //->Sector(Localpos[0], Localpos[2]);
+ //->Sector(localPos[0], localPos[2]);
//printf("Sector:%d\n",sector);
- gMC->TrackPosition(Position);
- gMC->TrackMomentum(Momentum);
- pos[0]=Position(0);
- pos[1]=Position(1);
- pos[2]=Position(2);
- mom[0]=Momentum(0);
- mom[1]=Momentum(1);
- mom[2]=Momentum(2);
- mom[3]=Momentum(3);
- gMC->Gmtod(pos,Localpos,1);
- gMC->Gmtod(mom,Localmom,2);
+ gMC->TrackPosition(position);
+ gMC->TrackMomentum(momentum);
+ pos[0]=position(0);
+ pos[1]=position(1);
+ pos[2]=position(2);
+ mom[0]=momentum(0);
+ mom[1]=momentum(1);
+ mom[2]=momentum(2);
+ mom[3]=momentum(3);
+ gMC->Gmtod(pos,localPos,1);
+ gMC->Gmtod(mom,localMom,2);
ipart = gMC->TrackPid();
//
phi = Float_t(TMath::ATan2(Double_t(mom[1]),Double_t(mom[0])))*kRaddeg;
- Double_t Localtc = Localmom[0]*Localmom[0]+Localmom[2]*Localmom[2];
- Double_t Localrt = TMath::Sqrt(Localtc);
- Localtheta = Float_t(TMath::ATan2(Localrt,Double_t(Localmom[1])))*kRaddeg;
- Localphi = Float_t(TMath::ATan2(Double_t(Localmom[2]),Double_t(Localmom[0])))*kRaddeg;
+ Double_t localTc = localMom[0]*localMom[0]+localMom[2]*localMom[2];
+ Double_t localRt = TMath::Sqrt(localTc);
+ localTheta = Float_t(TMath::ATan2(localRt,Double_t(localMom[1])))*kRaddeg;
+ localPhi = Float_t(TMath::ATan2(Double_t(localMom[2]),Double_t(localMom[0])))*kRaddeg;
hits[0] = Float_t(ipart); // particle type
- hits[1] = Localpos[0]; // X-position for hit
- hits[2] = Localpos[1]; // Y-position for hit
- hits[3] = Localpos[2]; // Z-position for hit
- hits[4] = Localtheta; // theta angle of incidence
- hits[5] = Localphi; // phi angle of incidence
+ hits[1] = localPos[0]; // X-position for hit
+ hits[2] = localPos[1]; // Y-position for hit
+ hits[3] = localPos[2]; // Z-position for hit
+ hits[4] = localTheta; // theta angle of incidence
+ hits[5] = localPhi; // phi angle of incidence
hits[8] = (Float_t) fNPadHits; // first padhit
hits[9] = -1; // last pad hit
- hits[13] = fFreon_prod;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff