X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliAlignmentTracks.cxx;h=e734e375bc5db3e31e3de9e684e9a62a2abb1e90;hb=d3ed0b8ee0f36f4527d5a845fbfeda9b117fbba4;hp=efc068e5674dfff7eddf21f5282daa84a5a947f9;hpb=7fa594d2ba3cdcfa1770b006a05d7bee346dd669;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliAlignmentTracks.cxx b/STEER/AliAlignmentTracks.cxx index efc068e5674..e734e375bc5 100644 --- a/STEER/AliAlignmentTracks.cxx +++ b/STEER/AliAlignmentTracks.cxx @@ -24,13 +24,15 @@ #include #include +#include +#include #include "AliAlignmentTracks.h" #include "AliTrackPointArray.h" -#include "AliAlignObjAngles.h" +#include "AliAlignObjParams.h" #include "AliTrackFitterRieman.h" #include "AliTrackResidualsChi2.h" -#include "AliESD.h" +#include "AliESDEvent.h" #include "AliLog.h" ClassImp(AliAlignmentTracks) @@ -48,7 +50,8 @@ AliAlignmentTracks::AliAlignmentTracks(): fMisalignObjs(0), fTrackFitter(0), fMinimizer(0), - fDoUpdate(kTRUE) + fDoUpdate(kTRUE), + fCovIsUsed(kFALSE) { // Default constructor InitIndex(); @@ -68,7 +71,8 @@ AliAlignmentTracks::AliAlignmentTracks(TChain *esdchain): fMisalignObjs(0), fTrackFitter(0), fMinimizer(0), - fDoUpdate(kTRUE) + fDoUpdate(kTRUE), + fCovIsUsed(kFALSE) { // Constructor in the case // the user provides an already @@ -91,7 +95,8 @@ AliAlignmentTracks::AliAlignmentTracks(const char *esdfilename, const char *esdt fMisalignObjs(0), fTrackFitter(0), fMinimizer(0), - fDoUpdate(kTRUE) + fDoUpdate(kTRUE), + fCovIsUsed(kFALSE) { // Constructor in the case // the user provides a single ESD file @@ -142,8 +147,15 @@ void AliAlignmentTracks::AddESD(const char *esdfilename, const char *esdtreename } } -//______________________________________________________________________________ -void AliAlignmentTracks::ProcessESD() + +//________________________________________________________________________ +void AliAlignmentTracks::ProcessESD(Bool_t onlyITS, + Int_t minITSpts, + Bool_t cuts, + Float_t minAngleWrtITSModulePlanes, + Float_t minMom,Float_t maxMom, + Float_t minAbsSinPhi,Float_t maxAbsSinPhi, + Float_t minSinTheta,Float_t maxSinTheta) { // Analyzes and filters ESD tracks // Stores the selected track space points @@ -151,14 +163,14 @@ void AliAlignmentTracks::ProcessESD() if (!fESDChain) return; - AliESD *esd = 0; - fESDChain->SetBranchAddress("ESD",&esd); + AliESDEvent *esd = new AliESDEvent(); + esd->ReadFromTree(fESDChain); AliESDfriend *esdf = 0; fESDChain->SetBranchStatus("ESDfriend*",1); fESDChain->SetBranchAddress("ESDfriend.",&esdf); // Open the output file - if (fPointsFilename.Data() == "") { + if (fPointsFilename.IsNull()) { AliWarning("Incorrect output filename!"); return; } @@ -171,7 +183,13 @@ void AliAlignmentTracks::ProcessESD() TTree *pointsTree = new TTree("spTree", "Tree with track space point arrays"); const AliTrackPointArray *array = 0; - pointsTree->Branch("SP","AliTrackPointArray", &array); + AliTrackPointArray *array2 = 0; + if(onlyITS) { // only ITS AliTrackPoints + pointsTree->Branch("SP","AliTrackPointArray", &array2); + } else { + pointsTree->Branch("SP","AliTrackPointArray", &array); + } + Int_t ievent = 0; while (fESDChain->GetEntry(ievent++)) { if (!esd) break; @@ -182,15 +200,57 @@ void AliAlignmentTracks::ProcessESD() for (Int_t itrack=0; itrack < ntracks; itrack++) { AliESDtrack * track = esd->GetTrack(itrack); if (!track) continue; - - // UInt_t status = AliESDtrack::kITSpid; -// status|=AliESDtrack::kTPCpid; -// status|=AliESDtrack::kTRDpid; -// if ((track->GetStatus() & status) != status) continue; - if (track->GetP() < 0.5) continue; + if(track->GetNcls(0) < minITSpts) continue; + if(cuts) { + if(track->GetP()GetP()>maxMom) continue; + Float_t abssinphi = TMath::Abs(TMath::Sin(track->GetAlpha()+TMath::ASin(track->GetSnp()))); + if(abssinphimaxAbsSinPhi) continue; + Float_t sintheta = TMath::Sin(0.5*TMath::Pi()-TMath::ATan(track->GetTgl())); + if(sinthetamaxSinTheta) continue; + } + AliTrackPoint point; array = track->GetTrackPointArray(); + + if(onlyITS) { + Bool_t layerOK[6]={kTRUE,kTRUE,kTRUE,kTRUE,kTRUE,kTRUE}; + Int_t ipt,volId,modId,layerId; + Int_t jpt=0; + for(ipt=0; iptGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6) continue; + // check minAngleWrtITSModulePlanes + if(cuts) { + Double_t p[3]; track->GetDirection(p); + TVector3 pvec(p[0],p[1],p[2]); + Double_t rot[9]; AliGeomManager::GetOrigRotation(volId,rot); + TVector3 normvec(rot[1],rot[4],rot[7]); + Double_t angle = pvec.Angle(normvec); + if(angle>0.5*TMath::Pi()) angle = TMath::Pi()-angle; + angle = 0.5*TMath::Pi()-angle; + if(angleGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6 || !layerOK[layerId-1]) continue; + array2->AddPoint(jpt,&point); + jpt++; + } + } // end if(onlyITS) + pointsTree->Fill(); } } @@ -201,6 +261,205 @@ void AliAlignmentTracks::ProcessESD() } pointsFile->Close(); + + return; +} + +//_____________________________________________________________________________ +void AliAlignmentTracks::ProcessESDCosmics(Bool_t onlyITS, + Int_t minITSpts,Float_t maxMatchingAngle, + Bool_t cuts, + Float_t minAngleWrtITSModulePlanes, + Float_t minMom,Float_t maxMom, + Float_t minAbsSinPhi,Float_t maxAbsSinPhi, + Float_t minSinTheta,Float_t maxSinTheta) +{ + // Analyzes and filters ESD tracks + // Merges inward and outward tracks in one single track + // Stores the selected track space points + // into the output file + + if (!fESDChain) return; + + AliESDEvent *esd = new AliESDEvent(); + esd->ReadFromTree(fESDChain); + AliESDfriend *esdf = 0; + fESDChain->SetBranchStatus("ESDfriend*",1); + fESDChain->SetBranchAddress("ESDfriend.",&esdf); + + // Open the output file + if (fPointsFilename.IsNull()) { + AliWarning("Incorrect output filename!"); + return; + } + + TFile *pointsFile = TFile::Open(fPointsFilename,"RECREATE"); + if (!pointsFile || !pointsFile->IsOpen()) { + AliWarning(Form("Can't open %s !",fPointsFilename.Data())); + return; + } + + TTree *pointsTree = new TTree("spTree", "Tree with track space point arrays"); + const AliTrackPointArray *array = 0; + AliTrackPointArray *array2 = 0; + pointsTree->Branch("SP","AliTrackPointArray", &array2); + + Int_t ievent = 0; + while (fESDChain->GetEntry(ievent++)) { + if (!esd) break; + + esd->SetESDfriend(esdf); //Attach the friend to the ESD + + Int_t ntracks = esd->GetNumberOfTracks(); + if(ntracks<2) continue; + Int_t *goodtracksArray = new Int_t[ntracks]; + Float_t *phiArray = new Float_t[ntracks]; + Float_t *thetaArray = new Float_t[ntracks]; + Int_t ngt=0; + for (Int_t itrack=0; itrack < ntracks; itrack++) { + AliESDtrack * track = esd->GetTrack(itrack); + if (!track) continue; + + if(track->GetNcls(0) < minITSpts) continue; + Float_t phi = track->GetAlpha()+TMath::ASin(track->GetSnp()); + Float_t theta = 0.5*TMath::Pi()-TMath::ATan(track->GetTgl()); + if(cuts) { + if(track->GetP()GetP()>maxMom) continue; + Float_t abssinphi = TMath::Abs(TMath::Sin(phi)); + if(abssinphimaxAbsSinPhi) continue; + Float_t sintheta = TMath::Sin(theta); + if(sinthetamaxSinTheta) continue; + } + goodtracksArray[ngt]=itrack; + phiArray[ngt]=phi; + thetaArray[ngt]=theta; + ngt++; + } + + if(ngt<2) { + delete [] goodtracksArray; goodtracksArray=0; + delete [] phiArray; phiArray=0; + delete [] thetaArray; thetaArray=0; + continue; + } + + // check matching of the two tracks from the muon + Float_t min = 10000000.; + Int_t good1 = -1, good2 = -1; + for(Int_t itr1=0; itr1maxMatchingAngle) continue; + Float_t deltaphi = TMath::Abs(TMath::Abs(phiArray[itr1]-phiArray[itr2])-TMath::Pi()); + if(deltaphi>maxMatchingAngle) continue; + //printf("%f %f %f %f\n",deltaphi,deltatheta,thetaArray[itr1],thetaArray[itr2]); + if(deltatheta+deltaphiGetTrack(good1); + AliESDtrack * track2 = esd->GetTrack(good2); + + AliTrackPoint point; + Int_t ipt,volId,modId,layerId; + Int_t jpt=0; + Bool_t layerOK[6][2]; + for(Int_t l1=0;l1<6;l1++) for(Int_t l2=0;l2<2;l2++) layerOK[l1][l2]=kTRUE; + array = track1->GetTrackPointArray(); + for(ipt=0; iptGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + if(onlyITS) { + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6) continue; + // check minAngleWrtITSModulePlanes + if(cuts) { + Double_t p[3]; track1->GetDirection(p); + TVector3 pvec(p[0],p[1],p[2]); + Double_t rot[9]; AliGeomManager::GetOrigRotation(volId,rot); + TVector3 normvec(rot[1],rot[4],rot[7]); + Double_t angle = pvec.Angle(normvec); + if(angle>0.5*TMath::Pi()) angle = TMath::Pi()-angle; + angle = 0.5*TMath::Pi()-angle; + if(angleGetTrackPointArray(); + for(ipt=0; iptGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + if(onlyITS) { + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6) continue; + // check minAngleWrtITSModulePlanes + if(cuts) { + Double_t p[3]; track2->GetDirection(p); + TVector3 pvec(p[0],p[1],p[2]); + Double_t rot[9]; AliGeomManager::GetOrigRotation(volId,rot); + TVector3 normvec(rot[1],rot[4],rot[7]); + Double_t angle = pvec.Angle(normvec); + if(angle>0.5*TMath::Pi()) angle = TMath::Pi()-angle; + angle = 0.5*TMath::Pi()-angle; + if(angleGetTrackPointArray(); + for(ipt=0; iptGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + if(onlyITS) { + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6 || !layerOK[layerId-1][0]) continue; + } + array2->AddPoint(jpt,&point); + jpt++; + } + array = track2->GetTrackPointArray(); + for(ipt=0; iptGetNPoints(); ipt++) { + array->GetPoint(point,ipt); + if(onlyITS) { + volId = point.GetVolumeID(); + layerId = AliGeomManager::VolUIDToLayer(volId,modId); + if(layerId>6 || !layerOK[layerId-1][1]) continue; + } + array2->AddPoint(jpt,&point); + jpt++; + } + + pointsTree->Fill(); + } + + if (!pointsTree->Write()) { + AliWarning("Can't write the tree with track point arrays!"); + return; + } + + pointsFile->Close(); + return; } //______________________________________________________________________________ @@ -220,7 +479,7 @@ void AliAlignmentTracks::BuildIndex() // Dummy object is created in order // to initialize the volume paths - AliAlignObjAngles alobj; + AliAlignObjParams alobj; fPointsFile = TFile::Open(fPointsFilename); if (!fPointsFile || !fPointsFile->IsOpen()) { @@ -245,14 +504,14 @@ void AliAlignmentTracks::BuildIndex() for (Int_t ipoint = 0; ipoint < array->GetNPoints(); ipoint++) { UShort_t volId = array->GetVolumeID()[ipoint]; // check if the volId is valid - if (!AliAlignObj::SymName(volId)) { + if (!AliGeomManager::SymName(volId)) { AliError(Form("The volume id %d has no default volume name !", volId)); continue; } Int_t modId; - Int_t layerId = AliAlignObj::VolUIDToLayer(volId,modId) - - AliAlignObj::kFirstLayer; + Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId) + - AliGeomManager::kFirstLayer; if (!fArrayIndex[layerId][modId]) { //first entry for this volume fArrayIndex[layerId][modId] = new TArrayI(1000); @@ -284,13 +543,13 @@ void AliAlignmentTracks::BuildIndex() void AliAlignmentTracks::InitIndex() { // Initialize the index arrays - Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; + Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::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 + AliAlignObj::kFirstLayer)]; - fArrayIndex[iLayer] = new TArrayI*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)]; - for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) { + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + fLastIndex[iLayer] = new Int_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)]; + fArrayIndex[iLayer] = new TArrayI*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)]; + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) { fLastIndex[iLayer][iModule] = 0; fArrayIndex[iLayer][iModule] = 0; } @@ -305,8 +564,8 @@ void AliAlignmentTracks::ResetIndex() fIsIndexBuilt = kFALSE; - for (Int_t iLayer = 0; iLayer < AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; iLayer++) { - for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) { + for (Int_t iLayer = 0; iLayer < AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer; iLayer++) { + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) { fLastIndex[iLayer][iModule] = 0; } } @@ -317,8 +576,8 @@ void AliAlignmentTracks::DeleteIndex() { // 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 + AliAlignObj::kFirstLayer); iModule++) { + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) { if (fArrayIndex[iLayer][iModule]) { delete fArrayIndex[iLayer][iModule]; fArrayIndex[iLayer][iModule] = 0; @@ -334,24 +593,50 @@ void AliAlignmentTracks::DeleteIndex() //______________________________________________________________________________ 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;ivolAt(ivol); + volid=a->GetVolUID(); + Int_t iModule; + AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule); + if(iLayerAliGeomManager::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; } //______________________________________________________________________________ void AliAlignmentTracks::InitAlignObjs() { // Initialize the alignment objects array - Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; + Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer; fAlignObjs = new AliAlignObj**[nLayers]; - for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) { - 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,kTRUE); + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + fAlignObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)]; + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) { + UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule); + fAlignObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE); } } } @@ -360,8 +645,8 @@ void AliAlignmentTracks::InitAlignObjs() void AliAlignmentTracks::ResetAlignObjs() { // 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 + AliAlignObj::kFirstLayer); iModule++) + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) fAlignObjs[iLayer][iModule]->SetPars(0,0,0,0,0,0); } } @@ -370,8 +655,8 @@ void AliAlignmentTracks::ResetAlignObjs() void AliAlignmentTracks::DeleteAlignObjs() { // 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 + AliAlignObj::kFirstLayer); iModule++) + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) if (fAlignObjs[iLayer][iModule]) delete fAlignObjs[iLayer][iModule]; delete [] fAlignObjs[iLayer]; @@ -380,11 +665,11 @@ void AliAlignmentTracks::DeleteAlignObjs() fAlignObjs = 0; } -void AliAlignmentTracks::AlignDetector(AliAlignObj::ELayerID firstLayer, - AliAlignObj::ELayerID lastLayer, - AliAlignObj::ELayerID layerRangeMin, - AliAlignObj::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 @@ -392,50 +677,54 @@ void AliAlignmentTracks::AlignDetector(AliAlignObj::ELayerID firstLayer, // Tracks are fitted only within // the range defined by the user. Int_t nModules = 0; - for (Int_t iLayer = firstLayer; iLayer < lastLayer; iLayer++) - nModules += AliAlignObj::LayerSize(iLayer); + for (Int_t iLayer = firstLayer; iLayer <= lastLayer; iLayer++) + nModules += AliGeomManager::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); iModule++) { - UShort_t volId = AliAlignObj::LayerToVolUID(iLayer,iModule); + for (Int_t iLayer = firstLayer; iLayer <= lastLayer; iLayer++) { + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) { + UShort_t volId = AliGeomManager::LayerToVolUID(iLayer,iModule); volIds.AddAt(volId,modnum); modnum++; } } + 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(AliAlignObj::ELayerID layer, - AliAlignObj::ELayerID layerRangeMin, - AliAlignObj::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. // Tracks are fitted only within // the range defined by the user. - Int_t nModules = AliAlignObj::LayerSize(layer); + Int_t nModules = AliGeomManager::LayerSize(layer); TArrayI volIds(nModules); for (Int_t iModule = 0; iModule < nModules; iModule++) { - UShort_t volId = AliAlignObj::LayerToVolUID(layer,iModule); + UShort_t volId = AliGeomManager::LayerToVolUID(layer,iModule); 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 @@ -447,16 +736,18 @@ void AliAlignmentTracks::AlignVolume(UShort_t volId, UShort_t volIdFit, 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, - AliAlignObj::ELayerID layerRangeMin, - AliAlignObj::ELayerID layerRangeMax, +Bool_t AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *volidsfit, + AliGeomManager::ELayerID layerRangeMin, + AliGeomManager::ELayerID layerRangeMax, Int_t iterations) { // Align a set of detector volumes. @@ -469,17 +760,19 @@ void AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *voli 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); @@ -493,26 +786,27 @@ void AliAlignmentTracks::AlignVolumes(const TArrayI *volids, const TArrayI *voli 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++) { UShort_t volid = (*volids)[iVolId]; Int_t iModule; - AliAlignObj::ELayerID iLayer = AliAlignObj::VolUIDToLayer(volid,iModule); - AliAlignObj *alignObj = fAlignObjs[iLayer-AliAlignObj::kFirstLayer][iModule]; + AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule); + AliAlignObj *alignObj = fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule]; *alignObj *= *minimizer->GetAlignObj(); - alignObj->Print(""); + 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 @@ -537,19 +831,19 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) { UShort_t volid = (*volids)[iVolId]; Int_t iModule; - AliAlignObj::ELayerID iLayer = AliAlignObj::VolUIDToLayer(volid,iModule); + AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule); // In case of empty index - if (fLastIndex[iLayer-AliAlignObj::kFirstLayer][iModule] == 0) { + if (fLastIndex[iLayer-AliGeomManager::kFirstLayer][iModule] == 0) { AliWarning(Form("There are no space-points belonging to the volume which is to be aligned (Volume ID =%d)!",volid)); continue; } - nArrays += fLastIndex[iLayer-AliAlignObj::kFirstLayer][iModule]; + nArrays += fLastIndex[iLayer-AliGeomManager::kFirstLayer][iModule]; } 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; } @@ -557,6 +851,7 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** 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; @@ -570,17 +865,20 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) { UShort_t volid = (*volids)[iVolId]; Int_t iModule; - AliAlignObj::ELayerID iLayer = AliAlignObj::VolUIDToLayer(volid,iModule); + AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule); - Int_t nArraysId = fLastIndex[iLayer-AliAlignObj::kFirstLayer][iModule]; - TArrayI *index = fArrayIndex[iLayer-AliAlignObj::kFirstLayer][iModule]; + Int_t nArraysId = fLastIndex[iLayer-AliGeomManager::kFirstLayer][iModule]; + TArrayI *index = fArrayIndex[iLayer-AliGeomManager::kFirstLayer][iModule]; AliTrackPoint p; for (Int_t iArrayId = 0; iArrayId < nArraysId; iArrayId++) { // 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!"); @@ -594,18 +892,18 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** for (Int_t iPoint = 0; iPoint < nPoints; iPoint++) { array->GetPoint(p,iPoint); Int_t modnum; - AliAlignObj::ELayerID layer = AliAlignObj::VolUIDToLayer(p.GetVolumeID(),modnum); + AliGeomManager::ELayerID layer = AliGeomManager::VolUIDToLayer(p.GetVolumeID(),modnum); // check if the layer id is valid - if ((layer < AliAlignObj::kFirstLayer) || - (layer >= AliAlignObj::kLastLayer)) { + if ((layer < AliGeomManager::kFirstLayer) || + (layer >= AliGeomManager::kLastLayer)) { AliError(Form("Layer index is invalid: %d (%d -> %d) !", - layer,AliAlignObj::kFirstLayer,AliAlignObj::kLastLayer-1)); + layer,AliGeomManager::kFirstLayer,AliGeomManager::kLastLayer-1)); continue; } - if ((modnum >= AliAlignObj::LayerSize(layer)) || + if ((modnum >= AliGeomManager::LayerSize(layer)) || (modnum < 0)) { AliError(Form("Module number inside layer %d is invalid: %d (0 -> %d)", - layer,modnum,AliAlignObj::LayerSize(layer))); + layer,modnum,AliGeomManager::LayerSize(layer))); continue; } @@ -613,14 +911,27 @@ Int_t AliAlignmentTracks::LoadPoints(const TArrayI *volids, AliTrackPointArray** // Switch it off in case of real // alignment job! if (fMisalignObjs) { - AliAlignObj *misalignObj = fMisalignObjs[layer-AliAlignObj::kFirstLayer][modnum]; + AliAlignObj *misalignObj = fMisalignObjs[layer-AliGeomManager::kFirstLayer][modnum]; if (misalignObj) misalignObj->Transform(p); } // End of misalignment - AliAlignObj *alignObj = fAlignObjs[layer-AliAlignObj::kFirstLayer][modnum]; - alignObj->Transform(p); + + AliAlignObj *alignObj = fAlignObjs[layer-AliGeomManager::kFirstLayer][modnum]; + 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++; @@ -678,11 +989,11 @@ Bool_t AliAlignmentTracks::Misalign(const char *misalignObjFileName, const char* // scenario since it will bias the results. // Initialize the misalignment objects array - Int_t nLayers = AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer; + Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer; fMisalignObjs = new AliAlignObj**[nLayers]; - for (Int_t iLayer = 0; iLayer < (AliAlignObj::kLastLayer - AliAlignObj::kFirstLayer); iLayer++) { - fMisalignObjs[iLayer] = new AliAlignObj*[AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer)]; - for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer + AliAlignObj::kFirstLayer); iModule++) + for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) { + fMisalignObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)]; + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) fMisalignObjs[iLayer][iModule] = 0x0; } @@ -704,13 +1015,44 @@ Bool_t AliAlignmentTracks::Misalign(const char *misalignObjFileName, const char* // Store the misalignment objects for further usage Int_t nObjs = array->GetEntriesFast(); - AliAlignObj::ELayerID layerId; // volume layer + AliGeomManager::ELayerID layerId; // volume layer Int_t modId; // volume ID inside the layer for(Int_t i=0; iUncheckedAt(i); alObj->GetVolUID(layerId,modId); - fMisalignObjs[layerId-AliAlignObj::kFirstLayer][modId] = alObj; + if(layerIdGetSymName())); + continue; + } + fMisalignObjs[layerId-AliGeomManager::kFirstLayer][modId] = alObj; } return kTRUE; } + + +//________________________________________________ +void AliAlignmentTracks::WriteRealignObjArray(TString outfilename,AliGeomManager::ELayerID layerRangeMin,AliGeomManager::ELayerID layerRangeMax){ + + Int_t last=0; + TClonesArray *clonesArray=new TClonesArray("AliAlignObjParams",2200); + TClonesArray &alo=*clonesArray; + for (Int_t iLayer = layerRangeMin-AliGeomManager::kFirstLayer; iLayer <= (layerRangeMax - AliGeomManager::kFirstLayer);iLayer++) { + + for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) { + + AliAlignObj *alignObj = fAlignObjs[iLayer][iModule]; + new(alo[last])AliAlignObjParams(*alignObj); + last++; + } + } + TFile *file=new TFile(outfilename.Data(),"RECREATE"); + file->cd(); + + alo.Write("ITSAlignObjs",TObject::kSingleKey); + file->Close(); + + + delete clonesArray; + return; +}