fIsIndexBuilt(kFALSE),
fMisalignObjs(0),
fTrackFitter(0),
- fMinimizer(0)
+ fMinimizer(0),
+ fDoUpdate(kTRUE)
{
// Default constructor
InitIndex();
fIsIndexBuilt(kFALSE),
fMisalignObjs(0),
fTrackFitter(0),
- fMinimizer(0)
+ fMinimizer(0),
+ fDoUpdate(kTRUE)
{
// Constructor in the case
// the user provides an already
fIsIndexBuilt(kFALSE),
fMisalignObjs(0),
fTrackFitter(0),
- fMinimizer(0)
+ fMinimizer(0),
+ fDoUpdate(kTRUE)
{
// Constructor in the case
// the user provides a single ESD file
}
TTree *pointsTree = new TTree("spTree", "Tree with track space point arrays");
- AliTrackPointArray *array = 0;
+ const AliTrackPointArray *array = 0;
pointsTree->Branch("SP","AliTrackPointArray", &array);
-
Int_t ievent = 0;
while (fESDChain->GetEntry(ievent++)) {
if (!esd) break;
fIsIndexBuilt = kTRUE;
+ // Dummy object is created in order
+ // to initialize the volume paths
+ AliAlignObjAngles alobj;
+
TFile *fPointsFile = TFile::Open(fPointsFilename);
if (!fPointsFile || !fPointsFile->IsOpen()) {
AliWarning(Form("Can't open %s !",fPointsFilename.Data()));
if (!array) continue;
for (Int_t ipoint = 0; ipoint < array->GetNPoints(); ipoint++) {
UShort_t volId = array->GetVolumeID()[ipoint];
+ // check if the volId is valid
+ if (!AliAlignObj::GetVolPath(volId)) {
+ AliError(Form("The volume id %d has no default volume path !",
+ volId));
+ continue;
+ }
Int_t modId;
Int_t layerId = AliAlignObj::VolUIDToLayer(volId,modId)
- AliAlignObj::kFirstLayer;
fLastIndex = new Int_t*[nLayers];
fArrayIndex = new TArrayI**[nLayers];
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- fLastIndex[iLayer] = new Int_t[AliAlignObj::LayerSize(iLayer)];
- fArrayIndex[iLayer] = new TArrayI*[AliAlignObj::LayerSize(iLayer)];
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+ fLastIndex[iLayer] = new Int_t[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+ fArrayIndex[iLayer] = new TArrayI*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
fLastIndex[iLayer][iModule] = 0;
fArrayIndex[iLayer][iModule] = 0;
}
fIsIndexBuilt = kFALSE;
for (Int_t iLayer = 0; iLayer < AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; iLayer++) {
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
fLastIndex[iLayer][iModule] = 0;
}
}
// Delete the index arrays
// Called by the destructor
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
if (fArrayIndex[iLayer][iModule]) {
delete fArrayIndex[iLayer][iModule];
fArrayIndex[iLayer][iModule] = 0;
Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer;
fAlignObjs = new AliAlignObj**[nLayers];
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- fAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
+ fAlignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) {
UShort_t volid = AliAlignObj::LayerToVolUID(iLayer+ AliAlignObj::kFirstLayer,iModule);
fAlignObjs[iLayer][iModule] = new AliAlignObjAngles("",volid,0,0,0,0,0,0);
}
{
// Reset the alignment objects array
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
fAlignObjs[iLayer][iModule]->SetPars(0,0,0,0,0,0);
}
}
{
// Delete the alignment objects array
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
if (fAlignObjs[iLayer][iModule])
delete fAlignObjs[iLayer][iModule];
delete [] fAlignObjs[iLayer];
// the range defined by the user.
Int_t nModules = 0;
for (Int_t iLayer = firstLayer; iLayer < lastLayer; iLayer++)
- nModules += AliAlignObj::LayerSize(iLayer - AliAlignObj::kFirstLayer);
+ nModules += AliAlignObj::LayerSize(iLayer);
TArrayI volIds(nModules);
Int_t modnum = 0;
for (Int_t iLayer = firstLayer; iLayer < lastLayer; iLayer++) {
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer - AliAlignObj::kFirstLayer); iModule++) {
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
UShort_t volId = AliAlignObj::LayerToVolUID(iLayer,iModule);
volIds.AddAt(volId,modnum);
modnum++;
// a given layer.
// Tracks are fitted only within
// the range defined by the user.
- Int_t nModules = AliAlignObj::LayerSize(layer - AliAlignObj::kFirstLayer);
+ Int_t nModules = AliAlignObj::LayerSize(layer);
TArrayI volIds(nModules);
for (Int_t iModule = 0; iModule < nModules; iModule++) {
UShort_t volId = AliAlignObj::LayerToVolUID(layer,iModule);
minimizer->InitAlignObj();
AliTrackFitter *fitter = CreateFitter();
for (Int_t iArray = 0; iArray < nArrays; iArray++) {
+ if (!points[iArray]) continue;
fitter->SetTrackPointArray(points[iArray], kFALSE);
- fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax);
+ if (fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax) == kFALSE) continue;
AliTrackPointArray *pVolId,*pTrack;
fitter->GetTrackResiduals(pVolId,pTrack);
minimizer->AddTrackPointArrays(pVolId,pTrack);
minimizer->Minimize();
// Update the alignment object(s)
- for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
+ if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
UShort_t volid = (*volids)[iVolId];
Int_t iModule;
AliAlignObj::ELayerID iLayer = AliAlignObj::VolUIDToLayer(volid,iModule);
- AliAlignObj *alignObj = fAlignObjs[iLayer-AliAlignObj::kFirstLayer][iModule];
+ AliAlignObj *alignObj = fAlignObjs[iLayer-AliAlignObj::kFirstLayer][iModule];
*alignObj *= *minimizer->GetAlignObj();
alignObj->Print("");
}
// Allocate the pointer to the space-point arrays
points = new AliTrackPointArray*[nArrays];
+ for (Int_t i = 0; i < nArrays; i++) points[i] = 0x0;
// Init the array used to flag already loaded tree entries
Bool_t *indexUsed = new Bool_t[fPointsTree->GetEntries()];
array->GetPoint(p,iPoint);
Int_t modnum;
AliAlignObj::ELayerID layer = AliAlignObj::VolUIDToLayer(p.GetVolumeID(),modnum);
+ // check if the layer id is valid
+ if ((layer < AliAlignObj::kFirstLayer) ||
+ (layer >= AliAlignObj::kLastLayer)) {
+ AliError(Form("Layer index is invalid: %d (%d -> %d) !",
+ layer,AliAlignObj::kFirstLayer,AliAlignObj::kLastLayer-1));
+ continue;
+ }
+ if ((modnum >= AliAlignObj::LayerSize(layer)) ||
+ (modnum < 0)) {
+ AliError(Form("Module number inside layer %d is invalid: %d (0 -> %d)",
+ layer,modnum,AliAlignObj::LayerSize(layer)));
+ continue;
+ }
// Misalignment is introduced here
// Switch it off in case of real
Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer;
fMisalignObjs = new AliAlignObj**[nLayers];
for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) {
- fMisalignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer)];
- for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++)
+ fMisalignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)];
+ for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++)
fMisalignObjs[iLayer][iModule] = 0x0;
}