,fWrapRMin(0)
,fWrapRMax(0)
,fWrapZSpan(0)
+ ,fLay2WrapV(0)
,fLayTurbo(0)
,fLayPhi0(0)
,fLayRadii(0)
,fLayZLength(0)
- ,fLaddPerLay(0)
- ,fModPerLadd(0)
- ,fLadThick(0)
- ,fLadWidth(0)
- ,fLadTilt(0)
+ ,fStavPerLay(0)
+ ,fUnitPerStave(0)
+ ,fStaveThick(0)
+ ,fStaveWidth(0)
+ ,fStaveTilt(0)
,fDetThick(0)
- ,fDetTypeID(0)
+ ,fChipTypeID(0)
,fBuildLevel(0)
,fUpGeom(0)
,fStaveModelIB(kIBModel0)
}
//______________________________________________________________________
-AliITSUv1::AliITSUv1(const char *title,const Int_t nlay)
+AliITSUv1::AliITSUv1(const char *title, Int_t nlay)
:AliITSU(title,nlay)
,fNWrapVol(0)
,fWrapRMin(0)
,fWrapRMax(0)
,fWrapZSpan(0)
+ ,fLay2WrapV(0)
,fLayTurbo(0)
,fLayPhi0(0)
,fLayRadii(0)
,fLayZLength(0)
- ,fLaddPerLay(0)
- ,fModPerLadd(0)
- ,fLadThick(0)
- ,fLadWidth(0)
- ,fLadTilt(0)
+ ,fStavPerLay(0)
+ ,fUnitPerStave(0)
+ ,fStaveThick(0)
+ ,fStaveWidth(0)
+ ,fStaveTilt(0)
,fDetThick(0)
- ,fDetTypeID(0)
+ ,fChipTypeID(0)
,fBuildLevel(0)
,fUpGeom(0)
,fStaveModelIB(kIBModel0)
for (Int_t j=0; j<fNLayers; j++)
fLayerName[j].Form("%s%d",AliITSUGeomTGeo::GetITSSensorPattern(),j); // See AliITSUv1Layer
//
- fLayTurbo = new Bool_t[fNLayers];
- 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];
- fDetThick = new Double_t[fNLayers];
- fDetTypeID = new UInt_t[fNLayers];
- fBuildLevel = new Int_t[fNLayers];
+ fLayTurbo = new Bool_t[fNLayers];
+ fLayPhi0 = new Double_t[fNLayers];
+ fLayRadii = new Double_t[fNLayers];
+ fLayZLength = new Double_t[fNLayers];
+ fStavPerLay = new Int_t[fNLayers];
+ fUnitPerStave = new Int_t[fNLayers];
+ fStaveThick = new Double_t[fNLayers];
+ fStaveWidth = new Double_t[fNLayers];
+ fStaveTilt = new Double_t[fNLayers];
+ fDetThick = new Double_t[fNLayers];
+ fChipTypeID = new UInt_t[fNLayers];
+ fBuildLevel = new Int_t[fNLayers];
fUpGeom = new AliITSUv1Layer*[fNLayers];
if (fNLayers > 0) { // if not, we'll Fatal-ize in CreateGeometry
for (Int_t j=0; j<fNLayers; j++) {
- fLayPhi0[j] = 0;
- fLayRadii[j] = 0.;
- fLayZLength[j] = 0.;
- fLaddPerLay[j] = 0;
- fModPerLadd[j] = 0;
- fLadWidth[j] = 0.;
- fDetThick[j] = 0.;
- fDetTypeID[j] = 0;
- fBuildLevel[j] = 0;
- fUpGeom[j] = 0;
+ fLayPhi0[j] = 0;
+ fLayRadii[j] = 0.;
+ fLayZLength[j] = 0.;
+ fStavPerLay[j] = 0;
+ fUnitPerStave[j] = 0;
+ fStaveWidth[j] = 0.;
+ fDetThick[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 [] fUnitPerStave;
+ delete [] fStaveThick;
+ delete [] fStaveWidth;
+ delete [] fStaveTilt;
delete [] fDetThick;
- delete [] fDetTypeID;
+ delete [] fChipTypeID;
delete [] fBuildLevel;
delete [] fUpGeom;
delete [] fWrapRMin;
delete [] fWrapRMax;
delete [] fWrapZSpan;
+ delete [] fLay2WrapV;
}
//______________________________________________________________________
-void AliITSUv1::AddAlignableVolumes() const{
+void AliITSUv1::AddAlignableVolumes() const
+{
// Creates entries for alignable volumes associating the symbolic volume
// name with the corresponding volume path.
//
// system
// For this, this function has to run before the misalignment because we
// are using the ideal positions in the AliITSgeom object.
- // Inputs:
- // none.
- // Outputs:
- // none.
- // Return:
- // none.
-
AliInfo("Add ITS alignable volumes");
if (!gGeoManager) { AliFatal("TGeoManager doesn't exist !"); return; }
- TString pth;
//
- pth = Form("ALIC_1/%s_2",AliITSUGeomTGeo::GetITSVolPattern());
- // RS: to be checked with MS
- if( !gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameITS(),pth.Data()) )
- AliFatal(Form("Unable to set alignable entry ! %s :: %s","ITS",pth.Data()));
+ TString path = Form("ALIC_1/%s_2",AliITSUGeomTGeo::GetITSVolPattern());
+ TString sname = AliITSUGeomTGeo::ComposeSymNameITS();
+ //
+ AliDebug(1,Form("%s <-> %s",sname.Data(),path.Data()));
+ if( !gGeoManager->SetAlignableEntry(sname.Data(),path.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s %s",sname.Data(),path.Data()));
//
- int modNum = 0;
+ int lastUID = 0;
+ for (int lr=0; lr<fNLayers; lr++) AddAlignableVolumesLayer(lr,path,lastUID);
//
- for (int lr=0; lr<fNLayers; lr++) {
+}
+
+//______________________________________________________________________
+void AliITSUv1::AddAlignableVolumesLayer(int lr, TString& parent,Int_t &lastUID) const
+{
+ // add alignable volumes for layer and its daughters
+ //
+ TString wrpV = fLay2WrapV[lr]!=-1 ? Form("%s%d_1/",AliITSUGeomTGeo::GetITSWrapVolPattern(),fLay2WrapV[lr]) : "";
+ TString path = Form("%s/%s%s%d_1",parent.Data(),wrpV.Data(),AliITSUGeomTGeo::GetITSLayerPattern(),lr);
+ TString sname = AliITSUGeomTGeo::ComposeSymNameLayer(lr);
+ AliDebug(1,Form("Add %s <-> %s", sname.Data(),path.Data()));
+ if ( !gGeoManager->SetAlignableEntry(sname.Data(),path.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s : %s",sname.Data(),path.Data()));
+ //
+ const AliITSUv1Layer* lrobj = fUpGeom[lr];
+ int nstaves = lrobj->GetNStavesPerParent();
+ for (int st=0; st<nstaves; st++) AddAlignableVolumesStave(lr,st,path,lastUID);
+ //
+}
+
+//______________________________________________________________________
+void AliITSUv1::AddAlignableVolumesStave(int lr, int st, TString& parent, Int_t &lastUID) const
+{
+ // add alignable volumes for stave and its daughters
+ //
+ TString path = Form("%s/%s%d_%d",parent.Data(),AliITSUGeomTGeo::GetITSStavePattern(),lr,st);
+ TString sname = AliITSUGeomTGeo::ComposeSymNameStave(lr,st);
+ AliDebug(1,Form("Add %s <-> %s", sname.Data(),path.Data()));
+ if ( !gGeoManager->SetAlignableEntry(sname.Data(),path.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s : %s",sname.Data(),path.Data()));
+ //
+ const AliITSUv1Layer* lrobj = fUpGeom[lr];
+ int nsstave = lrobj->GetNHalfStavesPerParent();
+ int start = nsstave>0 ? 0:-1;
+ //
+ for (int sst=start; sst<nsstave; sst++) AddAlignableVolumesHalfStave(lr,st,sst,path,lastUID);
+}
+
+//______________________________________________________________________
+void AliITSUv1::AddAlignableVolumesHalfStave(int lr, int st, int sst, TString& parent, Int_t &lastUID) const
+{
+ // add alignable volumes for halfstave (if any) and its daughters
+ //
+ TString path = parent;
+ if (sst>=0) {
+ path = Form("%s/%s%d_%d",parent.Data(),AliITSUGeomTGeo::GetITSHalfStavePattern(),lr,sst);
+ TString sname = AliITSUGeomTGeo::ComposeSymNameHalfStave(lr,st,sst);
+ AliDebug(1,Form("Add %s <-> %s", sname.Data(),path.Data()));
+ if ( !gGeoManager->SetAlignableEntry(sname.Data(),path.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s : %s",sname.Data(),path.Data()));
//
- pth = Form("ALIC_1/%s_2/%s%d_1",AliITSUGeomTGeo::GetITSVolPattern(),AliITSUGeomTGeo::GetITSLayerPattern(),lr);
- //printf("SetAlignable: %s %s\n",snm.Data(),pth.Data());
- gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameLayer(lr),pth.Data());
+ }
+ const AliITSUv1Layer* lrobj = fUpGeom[lr];
+ int nmodules = lrobj->GetNModulesPerParent();
+ int start = nmodules>0 ? 0:-1;
+ //
+ for (int md=start; md<nmodules; md++) AddAlignableVolumesModule(lr,st,sst,md,path,lastUID);
+}
+
+//______________________________________________________________________
+void AliITSUv1::AddAlignableVolumesModule(int lr, int st, int sst, int md, TString& parent, Int_t &lastUID) const
+{
+ // add alignable volumes for module (if any) and its daughters
+ //
+ TString path = parent;
+ if (md>=0) {
+ path = Form("%s/%s%d_%d",parent.Data(),AliITSUGeomTGeo::GetITSModulePattern(),lr,md);
+ TString sname = AliITSUGeomTGeo::ComposeSymNameModule(lr,st,sst,md);
+ AliDebug(1,Form("Add %s <-> %s", sname.Data(),path.Data()));
+ if ( !gGeoManager->SetAlignableEntry(sname.Data(),path.Data()) )
+ AliFatal(Form("Unable to set alignable entry ! %s : %s",sname.Data(),path.Data()));
//
- for (int ld=0; ld<fLaddPerLay[lr]; ld++) {
- //
- TString pthL = Form("%s/%s%d_%d",pth.Data(),AliITSUGeomTGeo::GetITSLadderPattern(),lr,ld);
- //printf("SetAlignable: %s %s\n",snmL.Data(),pthL.Data());
- gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameLadder(lr,ld),pthL.Data());
- //
- for (int md=0; md<fModPerLadd[lr]; md++) {
- //
- TString pthM = Form("%s/%s%d_%d",pthL.Data(),AliITSUGeomTGeo::GetITSModulePattern(),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++ );
- //
- gGeoManager->SetAlignableEntry(AliITSUGeomTGeo::ComposeSymNameModule(lr,ld,md),pthM.Data(),modUID);
- //
- }
- }
}
//
+ const AliITSUv1Layer* lrobj = fUpGeom[lr];
+ int nchips = lrobj->GetNChipsPerParent();
+ //
+ for (int ic=0; ic<nchips; ic++) AddAlignableVolumesChip(lr,st,sst,md,ic,path,lastUID);
+}
+
+//______________________________________________________________________
+void AliITSUv1::AddAlignableVolumesChip(int lr, int st, int sst, int md, int ch, TString& parent, Int_t &lastUID) const
+{
+ // add alignable volumes for chip
+ //
+ TString path = Form("%s/%s%d_%d",parent.Data(),AliITSUGeomTGeo::GetITSChipPattern(),lr,ch);
+ TString sname = AliITSUGeomTGeo::ComposeSymNameChip(lr,st,sst,md,ch);
+ int modUID = AliITSUGeomTGeo::ChipVolUID( lastUID++ );
+ //
+ AliDebug(1,Form("Add %s <-> %s : ID=%d", sname.Data(),path.Data(),modUID));
+ if ( !gGeoManager->SetAlignableEntry(sname,path.Data(),modUID) )
+ AliFatal(Form("Unable to set alignable entry ! %s : %s | %d",sname.Data(),path.Data(),modUID));
+ //
}
//______________________________________________________________________
if (fNLayers <= 0) AliFatal(Form("Wrong number of layers (%d)",fNLayers));
//
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 (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 (fStavPerLay[j] <= 0) AliFatal(Form("Wrong number of staves for layer %d (%d)",j,fStavPerLay[j]));
+ if (fUnitPerStave[j] <= 0) AliFatal(Form("Wrong number of chips for layer %d (%d)",j,fUnitPerStave[j]));
+ if (fStaveThick[j] < 0) AliFatal(Form("Wrong stave thickness for layer %d (%f)",j,fStaveThick[j]));
+ if (fLayTurbo[j] && fStaveWidth[j] <= 0) AliFatal(Form("Wrong stave width for layer %d (%f)",j,fStaveWidth[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 (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 (fStaveThick[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++)
}
}
//
+ fLay2WrapV = new Int_t[fNLayers];
+
// Now create the actual geometry
for (Int_t j=0; j<fNLayers; j++) {
TGeoVolume* dest = vITSV;
+ fLay2WrapV[j] = -1;
//
if (fLayTurbo[j]) {
fUpGeom[j] = new AliITSUv1Layer(j,kTRUE,kFALSE);
- fUpGeom[j]->SetLadderWidth(fLadWidth[j]);
- fUpGeom[j]->SetLadderTilt(fLadTilt[j]);
+ fUpGeom[j]->SetStaveWidth(fStaveWidth[j]);
+ fUpGeom[j]->SetStaveTilt(fStaveTilt[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]->SetNUnits(fUnitPerStave[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 (fDetThick[j] != 0) fUpGeom[j]->SetSensorThick(fDetThick[j]);
+ if (fStaveThick[j] != 0) fUpGeom[j]->SetStaveThick(fStaveThick[j]);
+ if (fDetThick[j] != 0) fUpGeom[j]->SetSensorThick(fDetThick[j]);
//
for (int iw=0;iw<fNWrapVol;iw++) {
if (fLayRadii[j]>fWrapRMin[iw] && fLayRadii[j]<fWrapRMax[iw]) {
if (fLayZLength[j]>=fWrapZSpan[iw]) AliFatal(Form("ZSpan %.3f of wrapper volume %d is less than ZSpan %.3f of layer %d",
fWrapZSpan[iw],iw,fLayZLength[j],j));
dest = wrapVols[iw];
- break;
+ fLay2WrapV[j] = iw;
+ break;
}
}
fUpGeom[j]->CreateLayer(dest);
}
//______________________________________________________________________
-void AliITSUv1::DefineLayer(const Int_t nlay, const double phi0, const Double_t r,
- const Double_t zlen, const Int_t nladd,
- const Int_t nmod, const Double_t lthick,
- const Double_t dthick, const UInt_t dettypeID,
- const Int_t buildLevel)
+void AliITSUv1::DefineLayer(Int_t nlay, double phi0, Double_t r,
+ Double_t zlen, Int_t nstav,
+ Int_t nunit, Double_t lthick,
+ Double_t dthick, UInt_t dettypeID,
+ Int_t buildLevel)
{
// Sets the layer parameters
// Inputs:
// 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
+ // nunit IB: number of chips per stave
+ // OB: number of modules per half stave
+ // 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)
// Outputs:
// none.
// Return:
// none.
-
+
+ AliInfo(Form("L# %d Phi:%+.3f R:%+7.3f DZ:%7.2f Nst:%2d Nunit:%2d Lthick:%.4f Dthick:%.4f DetID:%d B:%d",
+ nlay,phi0,r,zlen,nstav,nunit,lthick,dthick,dettypeID,buildLevel));
+
if (nlay >= fNLayers || nlay < 0) {
AliError(Form("Wrong layer number (%d)",nlay));
return;
fLayPhi0[nlay] = phi0;
fLayRadii[nlay] = r;
fLayZLength[nlay] = zlen;
- fLaddPerLay[nlay] = nladd;
- fModPerLadd[nlay] = nmod;
- fLadThick[nlay] = lthick;
+ fStavPerLay[nlay] = nstav;
+ fUnitPerStave[nlay] = nunit;
+ fStaveThick[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,
- Int_t nmod, Double_t width, Double_t tilt,
+void AliITSUv1::DefineLayerTurbo(Int_t nlay, Double_t phi0, Double_t r, Double_t zlen, Int_t nstav,
+ Int_t nunit, 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
+ // nunit IB: number of chips per stave
+ // OB: number of modules per half 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)
// Return:
// none.
+ AliInfo(Form("L# %d Phi:%+.3f R:%+7.3f DZ:%7.2f Nst:%2d Nunit:%2d W:%7.4f Tilt:%+.3f Lthick:%.4f Dthick:%.4f DetID:%d B:%d",
+ nlay,phi0,r,zlen,nstav,nunit,width,tilt,lthick,dthick,dettypeID,buildLevel));
+
if (nlay >= fNLayers || nlay < 0) {
AliError(Form("Wrong layer number (%d)",nlay));
return;
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;
+ fUnitPerStave[nlay] = nunit;
+ fStaveThick[nlay] = lthick;
+ fStaveWidth[nlay] = width;
+ fStaveTilt[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 IB: number of chips per stave
+ // OB: number of modules per half 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 = fUnitPerStave[nlay];
+ width = fStaveWidth[nlay];
+ tilt = fStaveTilt[nlay];
+ lthick = fStaveThick[nlay];
dthick = fDetThick[nlay];
- dettype= fDetTypeID[nlay];
+ dettype= fChipTypeID[nlay];
}
//______________________________________________________________________
// none.
// Return:
// none.
+ //
if(!(this->IsActive())) return;
- if(!(gMC->TrackCharge())) return;
+ if(!(TVirtualMC::GetMC()->TrackCharge())) return;
//
Int_t copy, lay = 0;
- Int_t id = gMC->CurrentVolID(copy);
+ Int_t id = TVirtualMC::GetMC()->CurrentVolID(copy);
Bool_t notSens = kFALSE;
while ((lay<fNLayers) && (notSens = (id!=fIdSens[lay]))) ++lay;
//printf("R: %.1f | Lay: %d NotSens: %d\n",positionRS.Pt(), lay, notSens);
if (notSens) return;
-
- if(gMC->IsTrackExiting()) {
- AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
- } // if Outer ITS mother Volume
-
+ //
+ if (lay < 0 || lay >= fNLayers) {
+ AliError(Form("Invalid value: lay=%d. Not an ITS sensitive volume",lay));
+ return; // not an ITS sensitive volume.
+ }
+ //
static TLorentzVector position, momentum; // Saves on calls to construtors
static AliITSUHit hit;// Saves on calls to constructors
-
+ //
TClonesArray &lhits = *(Hits());
- Int_t cpn0, cpn1, mod, status = 0;
+ Int_t chipID, status = 0;
//
// Track status
- if(gMC->IsTrackInside()) status += 1;
- if(gMC->IsTrackEntering()) status += 2;
- if(gMC->IsTrackExiting()) status += 4;
- if(gMC->IsTrackOut()) status += 8;
- if(gMC->IsTrackDisappeared()) status += 16;
- if(gMC->IsTrackStop()) status += 32;
- if(gMC->IsTrackAlive()) status += 64;
-
+ if(TVirtualMC::GetMC()->IsTrackInside()) status += 1;
+ if(TVirtualMC::GetMC()->IsTrackEntering()) status += 2;
+ if(TVirtualMC::GetMC()->IsTrackExiting()) {
+ AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
+ status += 4;
+ } // if Outer ITS mother Volume
+ if(TVirtualMC::GetMC()->IsTrackOut()) status += 8;
+ if(TVirtualMC::GetMC()->IsTrackDisappeared()) status += 16;
+ if(TVirtualMC::GetMC()->IsTrackStop()) status += 32;
+ if(TVirtualMC::GetMC()->IsTrackAlive()) status += 64;
//
// retrieve the indices with the volume path
//
- if (lay < 0 || lay >= fNLayers) {
- AliError(Form("Invalid value: lay=%d. Not an ITS sensitive volume",lay));
- return; // not an ITS sensitive volume.
- } else {
- copy = 1;
- gMC->CurrentVolOffID(1,cpn1);
- gMC->CurrentVolOffID(2,cpn0);
- } //
-
- mod = fGeomTGeo->GetModuleIndex(lay,cpn0,cpn1);
- //RS2DEL fInitGeom.DecodeDetector(mod,lay+1,cpn0,cpn1,copy);
+ TVirtualMC::GetMC()->TrackPosition(position);
+ int chip=-1,module=-1,sstave=-1,stave=-1,level=0; // volume copies on different levels
+ TVirtualMC::GetMC()->CurrentVolOffID(++level,chip);
+ if (fGeomTGeo->GetNModules(lay)>0) TVirtualMC::GetMC()->CurrentVolOffID(++level,module);
+ if (fGeomTGeo->GetNHalfStaves(lay)>0) TVirtualMC::GetMC()->CurrentVolOffID(++level,sstave);
+ TVirtualMC::GetMC()->CurrentVolOffID(++level,stave);
//
+ chipID = fGeomTGeo->GetChipIndex(lay,stave,sstave,module,chip);
// Fill hit structure.
//
- hit.SetModule(mod);
+ hit.SetChip(chipID);
hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
- gMC->TrackPosition(position);
- gMC->TrackMomentum(momentum);
+ TVirtualMC::GetMC()->TrackPosition(position);
+ TVirtualMC::GetMC()->TrackMomentum(momentum);
hit.SetPosition(position);
- hit.SetTime(gMC->TrackTime());
+ hit.SetTime(TVirtualMC::GetMC()->TrackTime());
hit.SetMomentum(momentum);
hit.SetStatus(status);
- hit.SetEdep(gMC->Edep());
+ hit.SetEdep(TVirtualMC::GetMC()->Edep());
hit.SetShunt(GetIshunt());
- if(gMC->IsTrackEntering()){
+ if(TVirtualMC::GetMC()->IsTrackEntering()){
hit.SetStartPosition(position);
- hit.SetStartTime(gMC->TrackTime());
+ hit.SetStartTime(TVirtualMC::GetMC()->TrackTime());
hit.SetStartStatus(status);
return; // don't save entering hit.
} // end if IsEntering
new(lhits[fNhits++]) AliITSUHit(hit); // Use Copy Construtor.
// Save old position... for next hit.
hit.SetStartPosition(position);
- hit.SetStartTime(gMC->TrackTime());
+ hit.SetStartTime(TVirtualMC::GetMC()->TrackTime());
hit.SetStartStatus(status);
return;
}
//______________________________________________________________________
-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