Fatal("AliGenCocktailAfterBurner::GetStack","Asked for non existing stack (%d)",n);
return 0;
}
- return ((AliStack*) ((*fInternalStacks)[n]) );
+ //PH return ((AliStack*) ((*fInternalStacks)[n]) );
+ return ((AliStack*) fInternalStacks->At(n) );
}
void AliGenCocktailAfterBurner::SetActiveEventNumber(Int_t actev)
/*
$Log$
+Revision 1.58 2001/07/26 15:05:29 hristov
+Use global gRandom generator (M.Ivanov)
+
Revision 1.57 2001/07/24 14:26:11 mariana
Introduce the function Digits2Reco() and write the defaults for simulation and reconstruction
AliITSDetType* AliITS::DetType(Int_t id)
{
//return pointer to id detector type
- return ((AliITSDetType*) (*fDetTypes)[id]);
+ //PH return ((AliITSDetType*) (*fDetTypes)[id]);
+ return ((AliITSDetType*) fDetTypes->At(id));
}
//___________________________________________
void AliITS::SetClasses(Int_t id, const char *digit, const char *cluster)
{
//set the digit and cluster classes to be used for the id detector type
- ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
+ //PH ((AliITSDetType*) (*fDetTypes)[id])->ClassNames(digit,cluster);
+ ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);
}
//___________________________________________
{
//set the response model for the id detector type
- ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
+ //PH ((AliITSDetType*) (*fDetTypes)[id])->ResponseModel(response);
+ ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);
}
{
//set the segmentation model for the id detector type
- ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
+ //PH ((AliITSDetType*) (*fDetTypes)[id])->SegmentationModel(seg);
+ ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);
}
{
//set the simulation model for the id detector type
- ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
+ //PH ((AliITSDetType*) (*fDetTypes)[id])->SimulationModel(sim);
+ ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);
}
//___________________________________________
{
//set the cluster finder model for the id detector type
- ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
+ //PH ((AliITSDetType*) (*fDetTypes)[id])->ReconstructionModel(reconst);
+ ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(reconst);
}
{
// add a real digit - as coming from data
- TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ //PH TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
new(ldigits[fNdtype[id]++]) AliITSdigit(digits);
}
// add a simulated digit
- TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ //PH TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
switch(id)
{
// add a simulated digit to the list
- TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ //PH TClonesArray &ldigits = *((TClonesArray*)(*fDtype)[id]);
+ TClonesArray &ldigits = *((TClonesArray*)fDtype->At(id));
switch(id)
{
case 0:
// add a cluster to the list
- TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
+ //PH TClonesArray &lcl = *((TClonesArray*)(*fCtype)[id]);
+ TClonesArray &lcl = *((TClonesArray*)fCtype->At(id));
switch(id)
{
Int_t i;
for (i=0;i<kNTYPES;i++ ) {
- if ((*fDtype)[i]) ((TClonesArray*)(*fDtype)[i])->Clear();
+ //PH if ((*fDtype)[i]) ((TClonesArray*)(*fDtype)[i])->Clear();
+ if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
if (fNdtype) fNdtype[i]=0;
}
}
//
// Reset number of digits and the digits array for this branch
//
- if ((*fDtype)[i]) ((TClonesArray*)(*fDtype)[i])->Clear();
+ //PH if ((*fDtype)[i]) ((TClonesArray*)(*fDtype)[i])->Clear();
+ if (fDtype->At(i)) ((TClonesArray*)fDtype->At(i))->Clear();
if (fNdtype) fNdtype[i]=0;
}
Int_t i;
for (i=0;i<kNTYPES;i++ ) {
- if ((*fCtype)[i]) ((TClonesArray*)(*fCtype)[i])->Clear();
+ //PH if ((*fCtype)[i]) ((TClonesArray*)(*fCtype)[i])->Clear();
+ if (fCtype->At(i)) ((TClonesArray*)fCtype->At(i))->Clear();
if (fNctype) fNctype[i]=0;
}
//
// Reset number of clusters and the clusters array for this branch
//
- if ((*fCtype)[i]) ((TClonesArray*)(*fCtype)[i])->Clear();
+ //PH if ((*fCtype)[i]) ((TClonesArray*)(*fCtype)[i])->Clear();
+ if (fCtype->At(i)) ((TClonesArray*)fCtype->At(i))->Clear();
if (fNctype) fNctype[i]=0;
}
AliITSDetType *iDetType=DetType(i);
iDetType->GetClassNames(digclass,clclass);
// clusters
- if(!(*fCtype)[i]) fCtype->AddAt(new TClonesArray(clclass,1000),i);
+ //PH if(!(*fCtype)[i]) fCtype->AddAt(new TClonesArray(clclass,1000),i);
+ if(!fCtype->At(i)) fCtype->AddAt(new TClonesArray(clclass,1000),i);
if (kNTYPES==3) sprintf(branchname,"%sClusters%s",GetName(),det[i]);
else sprintf(branchname,"%sClusters%d",GetName(),i+1);
if (fCtype) {
for (i=0; i<kNTYPES ;i++) {
DetType(i)->GetClassNames(digclass,clclass);
// digits
- if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+ //PH if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+ if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
else ResetDigits(i);
}
for (i=0; i<kNTYPES; i++) {
DetType(i)->GetClassNames(digclass,clclass);
// digits
- if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+ //PH if(!((*fDtype)[i])) fDtype->AddAt(new TClonesArray(digclass,1000),i);
+ if(!(fDtype->At(i))) fDtype->AddAt(new TClonesArray(digclass,1000),i);
else ResetDigits(i);
if (kNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
// return strip no of a digit
if (digit<0) return -1;
return (digit>(fNDigits-1))?-1 :
- ((AliITSdigitSSD*)((*fDigits)[(*fDigitsIndex)[digit]]))->GetStripNumber();
+ //PH ((AliITSdigitSSD*)((*fDigits)[(*fDigitsIndex)[digit]]))->GetStripNumber();
+ ((AliITSdigitSSD*)(fDigits->At((*fDigitsIndex)[digit])))->GetStripNumber();
}
/************************************************************/
Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit)
Int_t index,signal;
if (digit<0||digit>=fNDigits) return -1;
index = (*fDigitsIndex)[digit];
- signal = ((AliITSdigitSSD*)((*fDigits)[index]))->GetSignal();
+ //PH signal = ((AliITSdigitSSD*)((*fDigits)[index]))->GetSignal();
+ signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
/*
if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
digit,index, signal);
Char_t candNum[4];
sprintf(candNum,"%d",i+1);
sddName.Append(candNum);
- (*fHis)[i] = new TH1F(sddName.Data(),"SDD maps",
- scale*fMaxNofSamples,0.,(Float_t) scale*fMaxNofSamples);
+ //PH (*fHis)[i] = new TH1F(sddName.Data(),"SDD maps",
+ //PH scale*fMaxNofSamples,0.,(Float_t) scale*fMaxNofSamples);
+ fHis->AddAt(new TH1F(sddName.Data(),"SDD maps",
+ scale*fMaxNofSamples,0.,(Float_t) scale*fMaxNofSamples), i);
}
}
//
Int_t i;
for (i=0;i<fNofMaps;i++ ) {
- if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ //PH if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ if (fHis->At(i)) ((TH1F*)fHis->At(i))->Reset();
}
}
}
Int_t index = (wing-1)*fNofMaps/2 + anode-1;
- return (TH1F*)((*fHis)[index]);
+ //PH return (TH1F*)((*fHis)[index]);
+ return (TH1F*)(fHis->At(index));
}
//____________________________________________
hfile->cd();
Int_t i;
- for(i=0; i<fNofMaps; i++) (*fHis)[i]->Write(); //fAdcs[i]->Write();
+ //PH for(i=0; i<fNofMaps; i++) (*fHis)[i]->Write(); //fAdcs[i]->Write();
+ for(i=0; i<fNofMaps; i++) fHis->At(i)->Write(); //fAdcs[i]->Write();
return;
}
//____________________________________________
Char_t candnum[4];
sprintf(candnum,"%d",i+1);
spdname.Append(candnum);
- (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
- fNPixelsX,0.,(Float_t) fNPixelsX);
+ //PH (*fHis)[i] = new TH1F(spdname.Data(),"SPD maps",
+ //PH fNPixelsX,0.,(Float_t) fNPixelsX);
+ fHis->AddAt(new TH1F(spdname.Data(),"SPD maps",
+ fNPixelsX,0.,(Float_t) fNPixelsX), i);
}
}
//
Int_t i;
for(i=0;i<fNPixelsZ;i++ ) {
- if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ //PH if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ if (fHis->At(i)) ((TH1F*)fHis->At(i))->Reset();
}
}
Char_t pixelz[4];
sprintf(pixelz,"%d",i+1);
spdName.Append(pixelz);
- (*fHis)[i] = new TH1F(spdName.Data(),"SPD maps",
- fNPixelsX,0.,(Float_t) fNPixelsX);
+ //PH (*fHis)[i] = new TH1F(spdName.Data(),"SPD maps",
+ //PH fNPixelsX,0.,(Float_t) fNPixelsX);
+ fHis->AddAt(new TH1F(spdName.Data(),"SPD maps",
+ fNPixelsX,0.,(Float_t) fNPixelsX), i);
}
}
//
for ( int i=0;i<fNPixelsZ;i++ ) {
- if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ //PH if ((*fHis)[i]) ((TH1F*)(*fHis)[i])->Reset();
+ if (fHis->At(i)) ((TH1F*)fHis->At(i))->Reset();
}
}
/*
$Log$
+Revision 1.1 2001/07/25 17:28:32 morsch
+LHC related code. First commit.
+
*/
#include "AliLHC.h"
#include "AliLhcIRegion.h"
fNRegions = 0;
fNProcesses = 0;
fBeams = new TObjArray(2);
- (*fBeams)[0] = 0;
- (*fBeams)[1] = 0;
+ //PH (*fBeams)[0] = 0;
+ //PH (*fBeams)[1] = 0;
+ fBeams->AddAt(0,0);
+ fBeams->AddAt(0,1);
fTime = 0;
fTimeMax = 0;
}
**************************************************************************/
/*
$Log$
+Revision 1.53 2001/07/20 10:03:13 morsch
+Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
+
Revision 1.52 2001/06/14 13:49:22 hristov
Write a TreeD in SDigits2Digits method (needed to be compatible with alirun script)
fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
}
- AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
+ //PH AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
+ AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
chamber->SetGid(0);
// Default values for Z of chambers
// Add a MUON digit to the list
//
- TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
+ //PH TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
+ TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(id));
new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
}
// Add a MUON digit to the list
//
- TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
+ //PH TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
+ TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
}
// Reset number of digits and the digits array for this detector
//
for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
- if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear();
+ //PH if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear();
+ if ((*fDchambers)[i]) ((TClonesArray*)fDchambers->At(i))->Clear();
if (fNdch) fNdch[i]=0;
}
}
// Reset number of raw clusters and the raw clust array for this detector
//
for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
- if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
+ //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
+ if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
if (fNrawch) fNrawch[i]=0;
}
}
{
// Set the pad size for chamber id and cathode isec
Int_t i=2*(id-1);
- ((AliMUONChamber*) (*fChambers)[i]) ->SetPadSize(isec,p1,p2);
- ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
+ //PH ((AliMUONChamber*) (*fChambers)[i]) ->SetPadSize(isec,p1,p2);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
+ ((AliMUONChamber*) fChambers->At(i)) ->SetPadSize(isec,p1,p2);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
}
//___________________________________________
// Set Z values for all chambers (tracking and trigger)
// from the array pointed to by "Z"
for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
- ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
+ //PH ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
+ ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
return;
}
{
// Set the inverse charge slope for chamber id
Int_t i=2*(id-1);
- ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
- ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
}
//___________________________________________
{
// Set sigma of charge spread for chamber id
Int_t i=2*(id-1);
- ((AliMUONChamber*) (*fChambers)[i])->SetChargeSpread(p1,p2);
- ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSpread(p1,p2);
+ //PH ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
+ //PH ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
+ ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
}
//___________________________________________
{
// Set integration limits for charge spread
Int_t i=2*(id-1);
- ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
- ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
}
//___________________________________________
{
// Set maximum number for ADCcounts (saturation)
Int_t i=2*(id-1);
- ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
- ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
}
//___________________________________________
void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
{
// Set the segmentation for chamber id cathode isec
- ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
+ //PH ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
+ ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
}
//___________________________________________
void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
{
// Set the response for chamber id
- ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
+ //PH ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
+ ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
}
void AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
{
// Set ClusterFinder for chamber id
- ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
+ //PH ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
+ ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
}
void AliMUON::SetNsec(Int_t id, Int_t nsec)
{
// Set number of segmented cathods for chamber id
- ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
+ //PH ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
+ ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
}
//___________________________________________
// if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
- ((AliMUONChamber*) (*fChambers)[idvol])
+ //PH ((AliMUONChamber*) (*fChambers)[idvol])
+ ((AliMUONChamber*) fChambers->At(idvol))
->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
Int_t ic=0;
// if (idvol == 6) printf("\n nnew %d \n", nnew);
//
ResetRawClusters();
for (Int_t ich = 0; ich < 10; ich++) {
- AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
+ //PH AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
+ AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
gAlice->ResetDigits();
**************************************************************************/
/*
$Log$
+Revision 1.11 2001/07/20 10:03:14 morsch
+Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
+
Revision 1.10 2001/03/20 13:17:30 egangler
fChargeCorrel moved from AliMUONChamber to AliMUONResponse as decided by
January meeting.
// Initalisation ..
//
// ... for chamber segmentation
- if ((*fSegmentation)[0])
- ((AliSegmentation *) (*fSegmentation)[0])->Init(fId);
+ //PH if ((*fSegmentation)[0])
+ //PH ((AliSegmentation *) (*fSegmentation)[0])->Init(fId);
+ if (fSegmentation->At(0))
+ ((AliSegmentation *) fSegmentation->At(0))->Init(fId);
if (fnsec==2) {
- if ((*fSegmentation)[1])
- ((AliSegmentation *) (*fSegmentation)[1])->Init(fId);
+ //PH if ((*fSegmentation)[1])
+ //PH ((AliSegmentation *) (*fSegmentation)[1])->Init(fId);
+ if (fSegmentation->At(1))
+ ((AliSegmentation *) fSegmentation->At(1))->Init(fId);
}
}
{
// Ask segmentation if signal should be generated
if (fnsec==1) {
- return ((AliSegmentation*) (*fSegmentation)[0])
+ //PH return ((AliSegmentation*) (*fSegmentation)[0])
+ return ((AliSegmentation*) fSegmentation->At(0))
->SigGenCond(x, y, z) ;
} else {
- return (((AliSegmentation*) (*fSegmentation)[0])
+ //PH return (((AliSegmentation*) (*fSegmentation)[0])
+ return (((AliSegmentation*) fSegmentation->At(0))
->SigGenCond(x, y, z)) ||
- (((AliSegmentation*) (*fSegmentation)[1])
+ //PH (((AliSegmentation*) (*fSegmentation)[1])
+ (((AliSegmentation*) fSegmentation->At(1))
->SigGenCond(x, y, z)) ;
}
}
// Initialisation of segmentation for hit
//
if (fnsec==1) {
- ((AliSegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
+ //PH ((AliSegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
+ ((AliSegmentation*) fSegmentation->At(0))->SigGenInit(x, y, z) ;
} else {
- ((AliSegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
- ((AliSegmentation*) (*fSegmentation)[1])->SigGenInit(x, y, z) ;
+ //PH ((AliSegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
+ //PH ((AliSegmentation*) (*fSegmentation)[1])->SigGenInit(x, y, z) ;
+ ((AliSegmentation*) fSegmentation->At(0))->SigGenInit(x, y, z) ;
+ ((AliSegmentation*) fSegmentation->At(1))->SigGenInit(x, y, z) ;
}
}
qcheck=0;
Float_t qcath = qtot * (i==1? fCurrentCorrel : 1/fCurrentCorrel);
AliSegmentation * segmentation=
- (AliSegmentation *) (*fSegmentation)[i-1];
+ //PH (AliSegmentation *) (*fSegmentation)[i-1];
+ (AliSegmentation *) fSegmentation->At(i-1);
for (segmentation->FirstPad(xhit, yhit, zhit, dx, dy);
segmentation->MorePads();
segmentation->NextPad())
/*
$Log$
+Revision 1.13 2001/07/20 10:03:14 morsch
+Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
+
Revision 1.12 2001/05/16 14:57:17 alibrary
New files for folders and Stack
}
AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::Slat(Int_t index) const
-{ return ((AliMUONSegmentationSlatModule*) (*fSlats)[index]);}
+ //PH { return ((AliMUONSegmentationSlatModule*) (*fSlats)[index]);}
+{ return ((AliMUONSegmentationSlatModule*) fSlats->At(index));}
AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::
/*
$Log$
+Revision 1.20 2001/07/20 10:03:14 morsch
+Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
+
Revision 1.19 2001/05/16 14:57:17 alibrary
New files for folders and Stack
TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
{
// Get correction function
- return (TF1*) (*fCorrA)[isec];
+ //PH return (TF1*) (*fCorrA)[isec];
+ return (TF1*) fCorrA->At(isec);
}
AliMUONSegmentationV01& AliMUONSegmentationV01::operator
/*
$Log$
+Revision 1.13 2001/05/03 08:11:31 hristov
+stdlib.h included to define exit()
+
Revision 1.12 2001/04/25 14:50:42 gosset
Corrections to violations of coding conventions
{
// Set track parameters at TrackHit with index "indexHit"
// from the track parameters pointed to by "TrackParam".
- AliMUONTrackHit* trackHit = (AliMUONTrackHit*) ((*fTrackHitsPtr)[indexHit]);
+ //PH AliMUONTrackHit* trackHit = (AliMUONTrackHit*) ((*fTrackHitsPtr)[indexHit]);
+ AliMUONTrackHit* trackHit = (AliMUONTrackHit*) (fTrackHitsPtr->At(indexHit));
trackHit->SetTrackParam(TrackParam);
}
/*
$Log$
+ Revision 1.52 2001/05/16 14:57:20 alibrary
+ New files for folders and Stack
+
Revision 1.51 2001/05/14 10:18:55 hristov
Default arguments declared once
Int_t i;
for (i=0; i<kNCH ;i++) {
- (*fDchambers)[i] = new TClonesArray("AliRICHDigit",10000);
+ //PH (*fDchambers)[i] = new TClonesArray("AliRICHDigit",10000);
+ fDchambers->AddAt(new TClonesArray("AliRICHDigit",10000), i);
fNdch[i]=0;
}
//printf("Created fRwClusters with adress:%p",fRawClusters);
for (i=0; i<kNCH ;i++) {
- (*fRawClusters)[i] = new TClonesArray("AliRICHRawCluster",10000);
+ //PH (*fRawClusters)[i] = new TClonesArray("AliRICHRawCluster",10000);
+ fRawClusters->AddAt(new TClonesArray("AliRICHRawCluster",10000), i);
fNrawch[i]=0;
}
//fNrechits = new Int_t[kNCH];
for (i=0; i<kNCH ;i++) {
- (*fRecHits1D)[i] = new TClonesArray("AliRICHRecHit1D",1000);
+ //PH (*fRecHits1D)[i] = new TClonesArray("AliRICHRecHit1D",1000);
+ fRecHits1D->AddAt(new TClonesArray("AliRICHRecHit1D",1000), i);
}
for (i=0; i<kNCH ;i++) {
- (*fRecHits3D)[i] = new TClonesArray("AliRICHRecHit3D",1000);
+ //PH (*fRecHits3D)[i] = new TClonesArray("AliRICHRecHit3D",1000);
+ fRecHits3D->AddAt(new TClonesArray("AliRICHRecHit3D",1000), i);
}
//printf("Created fRecHits with adress:%p",fRecHits);
clhits[0]=fNhits+1;
- ((AliRICHChamber*) (*fChambers)[idvol])->DisIntegration(eloss, xhit, yhit, nnew, newclust, res);
+ //PH ((AliRICHChamber*) (*fChambers)[idvol])->DisIntegration(eloss, xhit, yhit, nnew, newclust, res);
+ ((AliRICHChamber*)fChambers->At(idvol))->DisIntegration(eloss, xhit, yhit, nnew, newclust, res);
Int_t ic=0;
//
//
//printf("fdigits:%p, data: %d\n",((TClonesArray*)(*fDchambers)[id]),digits[0]);
- TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
+ //PH TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
+ TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(id));
new(ldigits[fNdch[id]++]) AliRICHDigit(tracks,charges,digits);
}
// Add a RICH digit to the list
//
- TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
+ //PH TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
+ TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
new(lrawcl[fNrawch[id]++]) AliRICHRawCluster(c);
}
// Add a RICH reconstructed hit to the list
//
- TClonesArray &lrec1D = *((TClonesArray*)(*fRecHits1D)[id]);
+ //PH TClonesArray &lrec1D = *((TClonesArray*)(*fRecHits1D)[id]);
+ TClonesArray &lrec1D = *((TClonesArray*)fRecHits1D->At(id));
new(lrec1D[fNrechits1D[id]++]) AliRICHRecHit1D(id,rechit,photons,padsx,padsy);
}
// Add a RICH reconstructed hit to the list
//
- TClonesArray &lrec3D = *((TClonesArray*)(*fRecHits3D)[id]);
+ //PH TClonesArray &lrec3D = *((TClonesArray*)(*fRecHits3D)[id]);
+ TClonesArray &lrec3D = *((TClonesArray*)fRecHits3D->At(id));
new(lrec3D[fNrechits3D[id]++]) AliRICHRecHit3D(id,rechit);
}
// Reset number of digits and the digits array for this detector
//
for ( int i=0;i<kNCH;i++ ) {
- if (fDchambers && (*fDchambers)[i]) (*fDchambers)[i]->Clear();
+ //PH if (fDchambers && (*fDchambers)[i]) (*fDchambers)[i]->Clear();
+ if (fDchambers && fDchambers->At(i)) fDchambers->At(i)->Clear();
if (fNdch) fNdch[i]=0;
}
}
// 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();
+ //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
+ if (fRawClusters->At(i)) ((TClonesArray*)fRawClusters->At(i))->Clear();
if (fNrawch) fNrawch[i]=0;
}
}
//
for ( int i=0;i<kNCH;i++ ) {
- if ((*fRecHits1D)[i]) ((TClonesArray*)(*fRecHits1D)[i])->Clear();
+ //PH if ((*fRecHits1D)[i]) ((TClonesArray*)(*fRecHits1D)[i])->Clear();
+ if (fRecHits1D->At(i)) ((TClonesArray*)fRecHits1D->At(i))->Clear();
if (fNrechits1D) fNrechits1D[i]=0;
}
}
//
for ( int i=0;i<kNCH;i++ ) {
- if ((*fRecHits3D)[i]) ((TClonesArray*)(*fRecHits3D)[i])->Clear();
+ //PH if ((*fRecHits3D)[i]) ((TClonesArray*)(*fRecHits3D)[i])->Clear();
+ if (fRecHits3D->At(i)) ((TClonesArray*)fRecHits3D->At(i))->Clear();
if (fNrechits3D) fNrechits3D[i]=0;
}
}
//
- ((AliRICHChamber*) (*fChambers)[id])->GeometryModel(geometry);
+ //PH ((AliRICHChamber*) (*fChambers)[id])->GeometryModel(geometry);
+ ((AliRICHChamber*)fChambers->At(id))->GeometryModel(geometry);
}
//___________________________________________
// Setter for the RICH segmentation model
//
- ((AliRICHChamber*) (*fChambers)[id])->SetSegmentationModel(segmentation);
+ //PH ((AliRICHChamber*) (*fChambers)[id])->SetSegmentationModel(segmentation);
+ ((AliRICHChamber*)fChambers->At(id))->SetSegmentationModel(segmentation);
}
//___________________________________________
// Setter for the RICH response model
//
- ((AliRICHChamber*) (*fChambers)[id])->ResponseModel(response);
+ //PH ((AliRICHChamber*) (*fChambers)[id])->ResponseModel(response);
+ ((AliRICHChamber*)fChambers->At(id))->ResponseModel(response);
}
void AliRICH::SetReconstructionModel(Int_t id, AliRICHClusterFinder *reconst)
// Setter for the RICH reconstruction model (clusters)
//
- ((AliRICHChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
+ //PH ((AliRICHChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
+ ((AliRICHChamber*)fChambers->At(id))->SetReconstructionModel(reconst);
}
//___________________________________________
printf("Feedbacks:%d\n",fFeedbacks);
}*/
- ((AliRICHChamber*) (*fChambers)[idvol])
+ //PH ((AliRICHChamber*) (*fChambers)[idvol])
+ ((AliRICHChamber*)fChambers->At(idvol))
->SigGenInit(localPos[0], localPos[2], localPos[1]);
if(idvol<kNCH) {
ckovData[0] = gMC->TrackPid(); // particle type
if(idvol<kNCH) {
//
// Initialize hit position (cursor) in the segmentation model
- ((AliRICHChamber*) (*fChambers)[idvol])
+ //PH ((AliRICHChamber*) (*fChambers)[idvol])
+ ((AliRICHChamber*)fChambers->At(idvol))
->SigGenInit(localPos[0], localPos[2], localPos[1]);
}
}
// defined by the segmentation
// model (boundary crossing conditions)
} else if
- (((AliRICHChamber*) (*fChambers)[idvol])
+ //PH (((AliRICHChamber*) (*fChambers)[idvol])
+ (((AliRICHChamber*)fChambers->At(idvol))
->SigGenCond(localPos[0], localPos[2], localPos[1]))
{
- ((AliRICHChamber*) (*fChambers)[idvol])
+ //PH ((AliRICHChamber*) (*fChambers)[idvol])
+ ((AliRICHChamber*)fChambers->At(idvol))
->SigGenInit(localPos[0], localPos[2], localPos[1]);
if (eloss > 0)
{
gAlice->ResetDigits();
gAlice->TreeD()->GetEvent(0);
for (Int_t ich=0;ich<kNCH;ich++) {
- AliRICHChamber* iChamber=(AliRICHChamber*) (*fChambers)[ich];
+ //PH AliRICHChamber* iChamber=(AliRICHChamber*) (*fChambers)[ich];
+ AliRICHChamber* iChamber=(AliRICHChamber*)fChambers->At(ich);
TClonesArray *pRICHdigits = this->DigitsAddress(ich);
if (pRICHdigits == 0)
continue;
/*
$Log$
+ Revision 1.2 2000/10/02 15:53:28 jbarbosa
+ Fixed memory leak (delete fTrackList).
+
Revision 1.1 2000/06/12 15:35:17 jbarbosa
Cleaned up version.
AliRICHTransientDigit::~AliRICHTransientDigit()
{
- delete fTrackList;
+ if (fTrackList) {
+ fTrackList->Delete();
+ delete fTrackList;
+ }
}
/*
$Log$
+ Revision 1.22 2001/05/16 14:57:20 alibrary
+ New files for folders and Stack
+
Revision 1.21 2001/05/10 12:28:15 jbarbosa
Repositioned the RICH modules.
fChambers = new TObjArray(kNCH);
for (i=0; i<kNCH; i++) {
- (*fChambers)[i] = new AliRICHChamber();
+ //PH (*fChambers)[i] = new AliRICHChamber();
+ fChambers->AddAt(new AliRICHChamber(), i);
}
//
for (Int_t i=0; i<kNCH; i++) {
//printf ("i:%d",i);
- ( (AliRICHChamber*) (*fChambers)[i])->Init(i);
+ //PH ( (AliRICHChamber*) (*fChambers)[i])->Init(i);
+ ( (AliRICHChamber*) fChambers->At(i))->Init(i);
}
//
// 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);
+ //PH ((AliRICHChamber*)(*fChambers)[0])->SetGid(1);
+ //PH ((AliRICHChamber*)(*fChambers)[1])->SetGid(2);
+ //PH ((AliRICHChamber*)(*fChambers)[2])->SetGid(3);
+ //PH ((AliRICHChamber*)(*fChambers)[3])->SetGid(4);
+ //PH ((AliRICHChamber*)(*fChambers)[4])->SetGid(5);
+ //PH ((AliRICHChamber*)(*fChambers)[5])->SetGid(6);
+ //PH ((AliRICHChamber*)(*fChambers)[6])->SetGid(7);
+
+ ((AliRICHChamber*)fChambers->At(0))->SetGid(1);
+ ((AliRICHChamber*)fChambers->At(1))->SetGid(2);
+ ((AliRICHChamber*)fChambers->At(2))->SetGid(3);
+ ((AliRICHChamber*)fChambers->At(3))->SetGid(4);
+ ((AliRICHChamber*)fChambers->At(4))->SetGid(5);
+ ((AliRICHChamber*)fChambers->At(5))->SetGid(6);
+ ((AliRICHChamber*)fChambers->At(6))->SetGid(7);
segmentation=Chamber(0).GetSegmentationModel(0);
geometry=Chamber(0).GetGeometryModel();
/*
$Log$
+ Revision 1.14 2001/05/16 14:57:20 alibrary
+ New files for folders and Stack
+
Revision 1.13 2001/05/10 12:28:04 jbarbosa
Repositioned the RICH modules.
fChambers = new TObjArray(kNCH);
for (i=0; i<kNCH; i++) {
- (*fChambers)[i] = new AliRICHChamber();
+ //PH (*fChambers)[i] = new AliRICHChamber();
+ fChambers->AddAt(new AliRICHChamber(), i);
}
//
for (Int_t i=0; i<kNCH; i++) {
//printf ("i:%d",i);
- ( (AliRICHChamber*) (*fChambers)[i])->Init(i);
+ //PH ( (AliRICHChamber*) (*fChambers)[i])->Init(i);
+ ( (AliRICHChamber*)fChambers->At(i))->Init(i);
}
//
// 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);
+ //PH ((AliRICHChamber*)(*fChambers)[0])->SetGid(1);
+ //PH ((AliRICHChamber*)(*fChambers)[1])->SetGid(2);
+ //PH ((AliRICHChamber*)(*fChambers)[2])->SetGid(3);
+ //PH ((AliRICHChamber*)(*fChambers)[3])->SetGid(4);
+ //PH ((AliRICHChamber*)(*fChambers)[4])->SetGid(5);
+ //PH ((AliRICHChamber*)(*fChambers)[5])->SetGid(6);
+ //PH ((AliRICHChamber*)(*fChambers)[6])->SetGid(7);
+
+ ((AliRICHChamber*)fChambers->At(0))->SetGid(1);
+ ((AliRICHChamber*)fChambers->At(1))->SetGid(2);
+ ((AliRICHChamber*)fChambers->At(2))->SetGid(3);
+ ((AliRICHChamber*)fChambers->At(3))->SetGid(4);
+ ((AliRICHChamber*)fChambers->At(4))->SetGid(5);
+ ((AliRICHChamber*)fChambers->At(5))->SetGid(6);
+ ((AliRICHChamber*)fChambers->At(6))->SetGid(7);
+
segmentation=Chamber(0).GetSegmentationModel(0);
geometry=Chamber(0).GetGeometryModel();
// Manager and hits classes for set: RICH full version //
///////////////////////////////////////////////////////////
-#include "AliRICHv0.h"
+#include "AliRICH.h"
class AliRICHv1 : public AliRICH {