#include <TChain.h>
#include <TFile.h>
#include <TVector3.h>
+#include <TSystem.h>
#include "AliAlignmentTracks.h"
#include "AliTrackPointArray.h"
fMisalignObjs(0),
fTrackFitter(0),
fMinimizer(0),
- fDoUpdate(kTRUE)
+ fDoUpdate(kTRUE),
+ fCovIsUsed(kFALSE)
{
// Default constructor
InitIndex();
fMisalignObjs(0),
fTrackFitter(0),
fMinimizer(0),
- fDoUpdate(kTRUE)
+ fDoUpdate(kTRUE),
+ fCovIsUsed(kFALSE)
{
// Constructor in the case
// the user provides an already
fMisalignObjs(0),
fTrackFitter(0),
fMinimizer(0),
- fDoUpdate(kTRUE)
+ fDoUpdate(kTRUE),
+ fCovIsUsed(kFALSE)
{
// Constructor in the case
// the user provides a single ESD file
fESDChain->SetBranchAddress("ESDfriend.",&esdf);
// Open the output file
- if (fPointsFilename.Data() == "") {
+ if (fPointsFilename.IsNull()) {
AliWarning("Incorrect output filename!");
return;
}
fESDChain->SetBranchAddress("ESDfriend.",&esdf);
// Open the output file
- if (fPointsFilename.Data() == "") {
+ if (fPointsFilename.IsNull()) {
AliWarning("Incorrect output filename!");
return;
}
//______________________________________________________________________________
Bool_t AliAlignmentTracks::ReadAlignObjs(const char *alignObjFileName, const char* arrayName)
{
- // Read alignment object from a file
+ // Read alignment object from a file: update the alignobj already present with the one in the file
// To be replaced by a call to CDB
- AliWarning(Form("Method not yet implemented (%s in %s) !",arrayName,alignObjFileName));
+
+ if(gSystem->AccessPathName(alignObjFileName,kFileExists)){
+ printf("Wrong AlignObjs File Name \n");
+ return kFALSE;
+ }
- return kFALSE;
+ TFile *fRealign=TFile::Open(alignObjFileName);
+ if (!fRealign || !fRealign->IsOpen()) {
+ AliError(Form("Could not open Align Obj File file %s !",alignObjFileName));
+ return kFALSE;
+ }
+ printf("Getting TClonesArray \n");
+ TClonesArray *clnarray=(TClonesArray*)fRealign->Get(arrayName);
+ Int_t size=clnarray->GetSize();
+ UShort_t volid;
+
+ for(Int_t ivol=0;ivol<size;ivol++){
+ AliAlignObjParams *a=(AliAlignObjParams*)clnarray->At(ivol);
+ volid=a->GetVolUID();
+ Int_t iModule;
+ AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
+ if(iLayer<AliGeomManager::kFirstLayer||iLayer>AliGeomManager::kSSD2)continue;
+ printf("Updating volume: %d ,layer: %d module: %d \n",volid,iLayer,iModule);
+ *fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule] *= *a;
+ }
+
+ delete clnarray;
+ fRealign->Close();
+ return kTRUE;
}
//______________________________________________________________________________
fAlignObjs = 0;
}
-void AliAlignmentTracks::AlignDetector(AliGeomManager::ELayerID firstLayer,
- AliGeomManager::ELayerID lastLayer,
- AliGeomManager::ELayerID layerRangeMin,
- AliGeomManager::ELayerID layerRangeMax,
- Int_t iterations)
+Bool_t AliAlignmentTracks::AlignDetector(AliGeomManager::ELayerID firstLayer,
+ AliGeomManager::ELayerID lastLayer,
+ AliGeomManager::ELayerID layerRangeMin,
+ AliGeomManager::ELayerID layerRangeMax,
+ Int_t iterations)
{
// Align detector volumes within
// a given layer range
}
}
+ Bool_t result = kFALSE;
while (iterations > 0) {
- AlignVolumes(&volIds,0x0,layerRangeMin,layerRangeMax);
+ if (!(result = AlignVolumes(&volIds,0x0,layerRangeMin,layerRangeMax))) break;
iterations--;
}
+ return result;
}
//______________________________________________________________________________
-void AliAlignmentTracks::AlignLayer(AliGeomManager::ELayerID layer,
- AliGeomManager::ELayerID layerRangeMin,
- AliGeomManager::ELayerID layerRangeMax,
- Int_t iterations)
+Bool_t AliAlignmentTracks::AlignLayer(AliGeomManager::ELayerID layer,
+ AliGeomManager::ELayerID layerRangeMin,
+ AliGeomManager::ELayerID layerRangeMax,
+ Int_t iterations)
{
// Align detector volumes within
// a given layer.
volIds.AddAt(volId,iModule);
}
+ Bool_t result = kFALSE;
while (iterations > 0) {
- AlignVolumes(&volIds,0x0,layerRangeMin,layerRangeMax);
+ if (!(result = AlignVolumes(&volIds,0x0,layerRangeMin,layerRangeMax))) break;
iterations--;
}
+ return result;
}
//______________________________________________________________________________
-void AliAlignmentTracks::AlignVolume(UShort_t volId, UShort_t volIdFit,
+Bool_t AliAlignmentTracks::AlignVolume(UShort_t volId, UShort_t volIdFit,
Int_t iterations)
{
// Align single detector volume to
TArrayI volIdsFit(1);
volIdsFit.AddAt(volIdFit,0);
+ Bool_t result = kFALSE;
while (iterations > 0) {
- AlignVolumes(&volIds,&volIdsFit);
+ if (!(result = AlignVolumes(&volIds,&volIdsFit))) break;
iterations--;
}
+ return result;
}
//______________________________________________________________________________
-void AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *volidsfit,
+Bool_t AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *volidsfit,
AliGeomManager::ELayerID layerRangeMin,
AliGeomManager::ELayerID layerRangeMax,
Int_t iterations)
Int_t nVolIds = volids->GetSize();
if (nVolIds == 0) {
AliError("Volume IDs array is empty!");
- return;
+ return kFALSE;
}
-
+
// Load only the tracks with at least one
// space point in the set of volume (volids)
BuildIndex();
AliTrackPointArray **points;
+ Int_t pointsdim;
// Start the iterations
+ Bool_t result = kFALSE;
while (iterations > 0) {
- Int_t nArrays = LoadPoints(volids, points);
- if (nArrays == 0) return;
+ Int_t nArrays = LoadPoints(volids, points,pointsdim);
+ if (nArrays == 0) return kFALSE;
AliTrackResiduals *minimizer = CreateMinimizer();
minimizer->SetNTracks(nArrays);
fitter->GetTrackResiduals(pVolId,pTrack);
minimizer->AddTrackPointArrays(pVolId,pTrack);
}
- minimizer->Minimize();
+ if (!(result = minimizer->Minimize())) break;
// Update the alignment object(s)
if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
if(iterations==1)alignObj->Print("");
}
- UnloadPoints(nArrays, points);
+ UnloadPoints(pointsdim, points);
iterations--;
}
+ return result;
}
//______________________________________________________________________________
-Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** &points)
+Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** &points,Int_t &pointsdim)
{
// Load track point arrays with at least
// one space point in a given set of detector
if (nArrays == 0) {
AliError("There are no space-points belonging to all of the volumes which are to be aligned!");
- points = 0;
+ points = 0x0;
return 0;
}
fPointsTree->SetBranchAddress("SP", &array);
// Allocate the pointer to the space-point arrays
+ pointsdim=nArrays;
points = new AliTrackPointArray*[nArrays];
for (Int_t i = 0; i < nArrays; i++) points[i] = 0x0;
// Get tree entry
Int_t entry = (*index)[iArrayId];
- if (indexUsed[entry] == kTRUE) continue;
+ if (indexUsed[entry] == kTRUE) {
+ nArrays--;
+ continue;
+ }
fPointsTree->GetEvent(entry);
if (!array) {
AliWarning("Wrong space point array index!");
}
// End of misalignment
+
AliAlignObj *alignObj = fAlignObjs[layer-AliGeomManager::kFirstLayer][modnum];
- alignObj->Transform(p);
+ UShort_t volp=p.GetVolumeID();
+ Bool_t found=kFALSE;
+ if(fCovIsUsed){
+ for (Int_t iVol = 0; iVol < nVolIds; iVol++) {
+ UShort_t vol = (*volids)[iVol];
+ if(volp==vol){
+ alignObj->Transform(p,kFALSE);
+ found=kTRUE;
+ break;
+ }
+ }
+ }
+ if(!found)alignObj->Transform(p,fCovIsUsed);
points[iArray]->AddPoint(iPoint,&p);
}
iArray++;
{
AliAlignObj* alObj = (AliAlignObj*)array->UncheckedAt(i);
alObj->GetVolUID(layerId,modId);
+ if(layerId<AliGeomManager::kFirstLayer) {
+ AliWarning(Form("Alignment object is ignored: %s",alObj->GetSymName()));
+ continue;
+ }
fMisalignObjs[layerId-AliGeomManager::kFirstLayer][modId] = alObj;
}
return kTRUE;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff