,fLayPhi0(0)
,fLayRadii(0)
,fLayZLength(0)
- ,fLaddPerLay(0)
- ,fModPerLadd(0)
- ,fLadThick(0)
- ,fLadWidth(0)
- ,fLadTilt(0)
+ ,fStavPerLay(0)
+ ,fModPerStav(0)
+ ,fStaThick(0)
+ ,fStaWidth(0)
+ ,fStaTilt(0)
,fDetThick(0)
- ,fDetTypeID(0)
+ ,fChipTypeID(0)
,fBuildLevel(0)
,fUpGeom(0)
,fStaveModelIB(kIBModel0)
,fLayPhi0(0)
,fLayRadii(0)
,fLayZLength(0)
- ,fLaddPerLay(0)
- ,fModPerLadd(0)
- ,fLadThick(0)
- ,fLadWidth(0)
- ,fLadTilt(0)
+ ,fStavPerLay(0)
+ ,fModPerStav(0)
+ ,fStaThick(0)
+ ,fStaWidth(0)
+ ,fStaTilt(0)
,fDetThick(0)
- ,fDetTypeID(0)
+ ,fChipTypeID(0)
,fBuildLevel(0)
,fUpGeom(0)
,fStaveModelIB(kIBModel0)
fLayPhi0 = new Double_t[fNLayers];
fLayRadii = new Double_t[fNLayers];
fLayZLength = new Double_t[fNLayers];
- fLaddPerLay = new Int_t[fNLayers];
- fModPerLadd = new Int_t[fNLayers];
- fLadThick = new Double_t[fNLayers];
- fLadWidth = new Double_t[fNLayers];
- fLadTilt = new Double_t[fNLayers];
+ fStavPerLay = new Int_t[fNLayers];
+ fModPerStav = new Int_t[fNLayers];
+ fStaThick = new Double_t[fNLayers];
+ fStaWidth = new Double_t[fNLayers];
+ fStaTilt = new Double_t[fNLayers];
fDetThick = new Double_t[fNLayers];
- fDetTypeID = new UInt_t[fNLayers];
+ fChipTypeID = new UInt_t[fNLayers];
fBuildLevel = new Int_t[fNLayers];
fLayPhi0[j] = 0;
fLayRadii[j] = 0.;
fLayZLength[j] = 0.;
- fLaddPerLay[j] = 0;
- fModPerLadd[j] = 0;
- fLadWidth[j] = 0.;
+ fStavPerLay[j] = 0;
+ fModPerStav[j] = 0;
+ fStaWidth[j] = 0.;
fDetThick[j] = 0.;
- fDetTypeID[j] = 0;
+ fChipTypeID[j] = 0;
fBuildLevel[j] = 0;
fUpGeom[j] = 0;
}
delete [] fLayPhi0;
delete [] fLayRadii;
delete [] fLayZLength;
- delete [] fLaddPerLay;
- delete [] fModPerLadd;
- delete [] fLadThick;
- delete [] fLadWidth;
- delete [] fLadTilt;
+ delete [] fStavPerLay;
+ delete [] fModPerStav;
+ delete [] fStaThick;
+ delete [] fStaWidth;
+ delete [] fStaTilt;
delete [] fDetThick;
- delete [] fDetTypeID;
+ delete [] fChipTypeID;
delete [] fBuildLevel;
delete [] fUpGeom;
delete [] fWrapRMin;
// none.
// Return:
// none.
-
+ /*
AliInfo("Add ITS alignable volumes");
if (!gGeoManager) { AliFatal("TGeoManager doesn't exist !"); return; }
//printf("SetAlignable: %s %s\n",snm.Data(),pth.Data());
gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameLayer(lr),pth.Data());
//
- for (int ld=0; ld<fLaddPerLay[lr]; ld++) {
+ for (int ld=0; ld<fStavPerLay[lr]; ld++) {
//
- TString pthL = Form("%s/%s%d_%d",pth.Data(),AliITSUGeomTGeo::GetITSLadderPattern(),lr,ld);
+ TString pthL = Form("%s/%s%d_%d",pth.Data(),AliITSUGeomTGeo::GetITSStavePattern(),lr,ld);
//printf("SetAlignable: %s %s\n",snmL.Data(),pthL.Data());
- gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameLadder(lr,ld),pthL.Data());
+ gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameStave(lr,ld),pthL.Data());
//
- for (int md=0; md<fModPerLadd[lr]; md++) {
+ for (int md=0; md<fModPerStav[lr]; md++) {
//
- TString pthM = Form("%s/%s%d_%d",pthL.Data(),AliITSUGeomTGeo::GetITSModulePattern(),lr,md);
+ TString pthM = Form("%s/%s%d_%d",pthL.Data(),AliITSUGeomTGeo::GetITSChipPattern(),lr,md);
//
- // RS: Attention, this is a hack: AliGeomManager cannot accomodate all ITSU modules w/o
- // conflicts with TPC. For this reason we define the UID of the module to be simply its ID
- // int modUID = AliGeomManager::LayerToVolUID(lr+1,modNum++); // here modNum would be module within the layer
- int modUID = AliITSUGeomTGeo::ModuleVolUID( modNum++ );
+ // RS: Attention, this is a hack: AliGeomManager cannot accomodate all ITSU chips w/o
+ // conflicts with TPC. For this reason we define the UID of the chip to be simply its ID
+ // int modUID = AliGeomManager::LayerToVolUID(lr+1,modNum++); // here modNum would be chip within the layer
+ int modUID = AliITSUGeomTGeo::ChipVolUID( modNum++ );
//
- gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameModule(lr,ld,md),pthM.Data(),modUID);
+ gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameChip(lr,ld,md),pthM.Data(),modUID);
//
}
}
}
//
+ */
}
//______________________________________________________________________
for (Int_t j=0; j<fNLayers; j++) {
if (fLayRadii[j] <= 0) AliFatal(Form("Wrong layer radius for layer %d (%f)",j,fLayRadii[j]));
if (fLayZLength[j] <= 0) AliFatal(Form("Wrong layer length for layer %d (%f)",j,fLayZLength[j]));
- if (fLaddPerLay[j] <= 0) AliFatal(Form("Wrong number of ladders for layer %d (%d)",j,fLaddPerLay[j]));
- if (fModPerLadd[j] <= 0) AliFatal(Form("Wrong number of modules for layer %d (%d)",j,fModPerLadd[j]));
- if (fLadThick[j] < 0) AliFatal(Form("Wrong ladder thickness for layer %d (%f)",j,fLadThick[j]));
- if (fLayTurbo[j] && fLadWidth[j] <= 0) AliFatal(Form("Wrong ladder width for layer %d (%f)",j,fLadWidth[j]));
- if (fDetThick[j] < 0) AliFatal(Form("Wrong module thickness for layer %d (%f)",j,fDetThick[j]));
+ if (fStavPerLay[j] <= 0) AliFatal(Form("Wrong number of staves for layer %d (%d)",j,fStavPerLay[j]));
+ if (fModPerStav[j] <= 0) AliFatal(Form("Wrong number of chips for layer %d (%d)",j,fModPerStav[j]));
+ if (fStaThick[j] < 0) AliFatal(Form("Wrong stave thickness for layer %d (%f)",j,fStaThick[j]));
+ if (fLayTurbo[j] && fStaWidth[j] <= 0) AliFatal(Form("Wrong stave width for layer %d (%f)",j,fStaWidth[j]));
+ if (fDetThick[j] < 0) AliFatal(Form("Wrong chip thickness for layer %d (%f)",j,fDetThick[j]));
//
if (j > 0) {
if (fLayRadii[j]<=fLayRadii[j-1]) AliFatal(Form("Layer %d radius (%f) is smaller than layer %d radius (%f)",
j,fLayRadii[j],j-1,fLayRadii[j-1]));
} // if (j > 0)
- if (fLadThick[j] == 0) AliInfo(Form("Ladder thickness for layer %d not set, using default",j));
- if (fDetThick[j] == 0) AliInfo(Form("Module thickness for layer %d not set, using default",j));
+ if (fStaThick[j] == 0) AliInfo(Form("Stave thickness for layer %d not set, using default",j));
+ if (fDetThick[j] == 0) AliInfo(Form("Chip thickness for layer %d not set, using default",j));
} // for (Int_t j=0; j<fNLayers; j++)
//
if (fLayTurbo[j]) {
fUpGeom[j] = new AliITSUv1Layer(j,kTRUE,kFALSE);
- fUpGeom[j]->SetLadderWidth(fLadWidth[j]);
- fUpGeom[j]->SetLadderTilt(fLadTilt[j]);
+ fUpGeom[j]->SetStaveWidth(fStaWidth[j]);
+ fUpGeom[j]->SetStaveTilt(fStaTilt[j]);
}
else fUpGeom[j] = new AliITSUv1Layer(j,kFALSE);
//
fUpGeom[j]->SetPhi0(fLayPhi0[j]);
fUpGeom[j]->SetRadius(fLayRadii[j]);
fUpGeom[j]->SetZLength(fLayZLength[j]);
- fUpGeom[j]->SetNLadders(fLaddPerLay[j]);
- fUpGeom[j]->SetNModules(fModPerLadd[j]);
- fUpGeom[j]->SetDetType(fDetTypeID[j]);
+ fUpGeom[j]->SetNStaves(fStavPerLay[j]);
+ fUpGeom[j]->SetNChips(fModPerStav[j]);
+ fUpGeom[j]->SetChipType(fChipTypeID[j]);
fUpGeom[j]->SetBuildLevel(fBuildLevel[j]);
if (j < 3)
fUpGeom[j]->SetStaveModel(fStaveModelIB);
fUpGeom[j]->SetStaveModel(fStaveModelOB);
AliDebug(1,Form("fBuildLevel: %d\n",fBuildLevel[j]));
//
- if (fLadThick[j] != 0) fUpGeom[j]->SetLadderThick(fLadThick[j]);
+ if (fStaThick[j] != 0) fUpGeom[j]->SetStaveThick(fStaThick[j]);
if (fDetThick[j] != 0) fUpGeom[j]->SetSensorThick(fDetThick[j]);
//
for (int iw=0;iw<fNWrapVol;iw++) {
//______________________________________________________________________
void AliITSUv1::DefineLayer(const Int_t nlay, const double phi0, const Double_t r,
- const Double_t zlen, const Int_t nladd,
+ const Double_t zlen, const Int_t nstav,
const Int_t nmod, const Double_t lthick,
const Double_t dthick, const UInt_t dettypeID,
const Int_t buildLevel)
// phi0 layer phi0
// r layer radius
// zlen layer length
- // nladd number of ladders
- // nmod number of modules per ladder
- // lthick ladder thickness (if omitted, defaults to 0)
+ // nstav number of staves
+ // nmod number of chips per stave
+ // lthick stave thickness (if omitted, defaults to 0)
// dthick detector thickness (if omitted, defaults to 0)
// buildLevel (if 0, all geometry is build, used for material budget studies)
// Outputs:
fLayPhi0[nlay] = phi0;
fLayRadii[nlay] = r;
fLayZLength[nlay] = zlen;
- fLaddPerLay[nlay] = nladd;
- fModPerLadd[nlay] = nmod;
- fLadThick[nlay] = lthick;
+ fStavPerLay[nlay] = nstav;
+ fModPerStav[nlay] = nmod;
+ fStaThick[nlay] = lthick;
fDetThick[nlay] = dthick;
- fDetTypeID[nlay] = dettypeID;
+ fChipTypeID[nlay] = dettypeID;
fBuildLevel[nlay] = buildLevel;
}
//______________________________________________________________________
-void AliITSUv1::DefineLayerTurbo(Int_t nlay, Double_t phi0, Double_t r, Double_t zlen, Int_t nladd,
+void AliITSUv1::DefineLayerTurbo(Int_t nlay, Double_t phi0, Double_t r, Double_t zlen, Int_t nstav,
Int_t nmod, Double_t width, Double_t tilt,
Double_t lthick,Double_t dthick,
UInt_t dettypeID, Int_t buildLevel)
{
// Sets the layer parameters for a "turbo" layer
- // (i.e. a layer whose ladders overlap in phi)
+ // (i.e. a layer whose staves overlap in phi)
// Inputs:
// nlay layer number
- // phi0 phi of 1st ladder
+ // phi0 phi of 1st stave
// r layer radius
// zlen layer length
- // nladd number of ladders
- // nmod number of modules per ladder
- // width ladder width
+ // nstav number of staves
+ // nmod number of chips per stave
+ // width stave width
// tilt layer tilt angle (degrees)
- // lthick ladder thickness (if omitted, defaults to 0)
+ // lthick stave thickness (if omitted, defaults to 0)
// dthick detector thickness (if omitted, defaults to 0)
// dettypeID ??
// buildLevel (if 0, all geometry is build, used for material budget studies)
fLayPhi0[nlay] = phi0;
fLayRadii[nlay] = r;
fLayZLength[nlay] = zlen;
- fLaddPerLay[nlay] = nladd;
- fModPerLadd[nlay] = nmod;
- fLadThick[nlay] = lthick;
- fLadWidth[nlay] = width;
- fLadTilt[nlay] = tilt;
+ fStavPerLay[nlay] = nstav;
+ fModPerStav[nlay] = nmod;
+ fStaThick[nlay] = lthick;
+ fStaWidth[nlay] = width;
+ fStaTilt[nlay] = tilt;
fDetThick[nlay] = dthick;
- fDetTypeID[nlay] = dettypeID;
+ fChipTypeID[nlay] = dettypeID;
fBuildLevel[nlay] = buildLevel;
}
//______________________________________________________________________
void AliITSUv1::GetLayerParameters(Int_t nlay, Double_t &phi0,
Double_t &r, Double_t &zlen,
- Int_t &nladd, Int_t &nmod,
+ Int_t &nstav, Int_t &nmod,
Double_t &width, Double_t &tilt,
Double_t <hick, Double_t &dthick,
UInt_t &dettype) const
// Inputs:
// nlay layer number
// Outputs:
- // phi0 phi of 1st ladder
+ // phi0 phi of 1st stave
// r layer radius
// zlen layer length
- // nladd number of ladders
- // nmod number of modules per ladder
- // width ladder width
- // tilt ladder tilt angle
- // lthick ladder thickness
+ // nstav number of staves
+ // nmod number of chips per stave
+ // width stave width
+ // tilt stave tilt angle
+ // lthick stave thickness
// dthick detector thickness
// dettype detector type
// Return:
phi0 = fLayPhi0[nlay];
r = fLayRadii[nlay];
zlen = fLayZLength[nlay];
- nladd = fLaddPerLay[nlay];
- nmod = fModPerLadd[nlay];
- width = fLadWidth[nlay];
- tilt = fLadTilt[nlay];
- lthick = fLadThick[nlay];
+ nstav = fStavPerLay[nlay];
+ nmod = fModPerStav[nlay];
+ width = fStaWidth[nlay];
+ tilt = fStaTilt[nlay];
+ lthick = fStaThick[nlay];
dthick = fDetThick[nlay];
- dettype= fDetTypeID[nlay];
+ dettype= fChipTypeID[nlay];
}
//______________________________________________________________________
gMC->CurrentVolOffID(2,cpn0);
} //
- mod = fGeomTGeo->GetModuleIndex(lay,cpn0,cpn1);
+ mod = fGeomTGeo->GetChipIndex(lay,cpn0,cpn1);
//RS2DEL fInitGeom.DecodeDetector(mod,lay+1,cpn0,cpn1,copy);
//
// Fill hit structure.
//
- hit.SetModule(mod);
+ hit.SetChip(mod);
hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
gMC->TrackPosition(position);
gMC->TrackMomentum(momentum);
}
//______________________________________________________________________
-void AliITSUv1::SetLayerDetTypeID(Int_t lr, UInt_t id)
+void AliITSUv1::SetLayerChipTypeID(Int_t lr, UInt_t id)
{
// set det type
- if (!fDetTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
- fDetTypeID[lr] = id;
+ if (!fChipTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
+ fChipTypeID[lr] = id;
}
//______________________________________________________________________
-Int_t AliITSUv1::GetLayerDetTypeID(Int_t lr)
+Int_t AliITSUv1::GetLayerChipTypeID(Int_t lr)
{
// set det type
- if (!fDetTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
- return fDetTypeID[lr];
+ if (!fChipTypeID || fNLayers<=lr) AliFatal(Form("Number of layers %d, %d is manipulated",fNLayers,lr));
+ return fChipTypeID[lr];
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff