Skip to content

Commit

Permalink
Usage of reference correction map implemented
Browse files Browse the repository at this point in the history 
Added loading of the reference correction map from TPC/Calib/CorrectionMapsRef on top of the
run-dependent TPC/Calib/CorrectionMap.
It should be prepared as an TObjArray of maps per field polarity, with corresponding polarity flag set.
If RecoParam->GetUseDistortionFractionAsErrorY() and GetUseDistortionFractionAsErrorZ() are non-zero,
the cluster will get addtinal error assigned as squared corresponding fraction for difference between the time-dependent
and reference maps
  • Loading branch information
@shahor02
shahor02 committed Mar 16, 2016
1 parent 4079f4a commit f86236f
Show file tree
Hide file tree
Showing 5 changed files with 123 additions and 38 deletions.
8 changes: 6 additions & 2 deletions TPC/TPCbase/AliTPCChebCorr.cxx
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,8 @@

ClassImp(AliTPCChebCorr)

const char* AliTPCChebCorr::fgkFieldTypeName[4] = {"Any","B>0"," B<0","B=0"};

const float AliTPCChebCorr::fgkY2XHSpan = TMath::Tan(TMath::Pi()/18);

const float AliTPCChebCorr::fgkPadRowX[AliTPCChebCorr::kNRows] = {
Expand All @@ -40,6 +42,7 @@ const float AliTPCChebCorr::fgkPadRowX[AliTPCChebCorr::kNRows] = {
//____________________________________________________________________
AliTPCChebCorr::AliTPCChebCorr()
: TNamed()
,fFieldType(kFieldAny)
,fNRows(0)
,fNStacksSect(0)
,fNStacksZSect(0)
Expand All @@ -61,6 +64,7 @@ AliTPCChebCorr::AliTPCChebCorr()
AliTPCChebCorr::AliTPCChebCorr(const char* name, const char* title,
int nps, int nzs, float zmaxAbs, float deadZone, const float *xrow)
: TNamed(name,title)
,fFieldType(kFieldAny)
,fNRows(kNRows)
,fNStacksSect(0)
,fNStacksZSect(0)
Expand Down Expand Up @@ -214,8 +218,8 @@ void AliTPCChebCorr::Print(const Option_t* opt) const
printf("%s:%s Cheb2D[%c] Param: %d slices in %+.1f<%s<%+.1f %d per sector. DeadZone: %.1fcm\n",
GetName(),GetTitle(),GetUseFloatPrec()?'F':'S',
fNStacksZ,-fZMaxAbs,GetUseZ2R() ? "Z/R":"Z",fZMaxAbs,fNStacksSect,fDeadZone);
printf("Time span: %ld:%ld TimeDependent flag: %s\n",fTimeStampStart,fTimeStampEnd,
GetTimeDependent() ? "ON":"OFF");
printf("Time span: %ld:%ld TimeDependent flag: %s Field type: %s\n",fTimeStampStart,fTimeStampEnd,
GetTimeDependent() ? "ON ":"OFF", fgkFieldTypeName[fFieldType]);
TString opts = opt; opts.ToLower();
if (opts.Contains("p") && TestBit(kParamDone)) {
for (int iz=0;iz<fNStacksZ;iz++) {
Expand Down
7 changes: 6 additions & 1 deletion TPC/TPCbase/AliTPCChebCorr.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,6 +35,7 @@
class AliTPCChebCorr : public TNamed
{
public:
enum {kFieldAny, kFieldPos, kFieldNeg, kFieldZero};
enum {kNSectors=18,kNSectorsIROC=2*kNSectors,kNRows=159,kNRowsIROC=63,kMaxIROCSector=kNSectorsIROC-1};
enum {kParamDone=BIT(14), // parameterization done
kUseParF=BIT(15), // if ON - internal FLOAT representation, otherwise - SHORT
Expand All @@ -47,6 +48,8 @@ class AliTPCChebCorr : public TNamed
AliTPCChebCorr();
AliTPCChebCorr(const char* name, const char* title, int nps=1,int nzs=1, float zmaxAbs=250, float deadZone=1.5, const float *xi=0);
virtual ~AliTPCChebCorr();
Int_t GetFieldType() const {return fFieldType;}
void SetFieldType(Char_t t=kFieldAny) {fFieldType = t;}
void Parameterize(stFun_t fun,int dimOut,const int np[2], const float *prec=0);
void Parameterize(stFun_t fun,int dimOut,const int np[][2], const float *prec=0);
void SetBinning(int nps=1,int nzs=1, float zmxAbs=250);
Expand Down Expand Up @@ -90,6 +93,7 @@ class AliTPCChebCorr : public TNamed
int GetParID(int iz,int isect,int istack) const {return (iz*kNSectors+isect)*fNStacksSect+istack;}
//
protected:
Char_t fFieldType; // info about the field type
Int_t fNRows; // number of slices along the radius (e.g. rows)
Int_t fNStacksSect; // number of stacks per sector in phi
Int_t fNStacksZSect; // number of stacks per sector (side) in Z
Expand All @@ -111,12 +115,13 @@ class AliTPCChebCorr : public TNamed
//
static const float fgkY2XHSpan; // half span of sector
static const float fgkPadRowX[]; // nominal rows
static const char* fgkFieldTypeName[]; // names of field types
protected:
//
AliTPCChebCorr(const AliTPCChebCorr& src); // dummy
AliTPCChebCorr& operator=(const AliTPCChebCorr& rhs); // dummy
//
ClassDef(AliTPCChebCorr,3)
ClassDef(AliTPCChebCorr,4)
};

//_________________________________________________________________
Expand Down
99 changes: 86 additions & 13 deletions TPC/TPCbase/AliTPCTransform.cxx
View file
Original file line number Diff line number Diff line change
Expand Up @@ -87,6 +87,7 @@ const Double_t AliTPCTransform::fgkMaxY2X = TMath::Tan(TMath::Pi()/18); //
AliTPCTransform::AliTPCTransform():
AliTransform(),
fCurrentRecoParam(0), //! current reconstruction parameters
fCorrMapCacheRef(0),
fCorrMapCache0(0),
fCorrMapCache1(0),
fCurrentRun(0), //! current run
Expand All @@ -105,10 +106,13 @@ AliTPCTransform::AliTPCTransform():
fPrimVtx[1]=0;
fPrimVtx[2]=0;
fLastCorr[0]=fLastCorr[1]=fLastCorr[2] = 0;
fLastCorrRef[0]=fLastCorrRef[1]=fLastCorrRef[2] = 0;
}

AliTPCTransform::AliTPCTransform(const AliTPCTransform& transform):
AliTransform(transform),
fCurrentRecoParam(transform.fCurrentRecoParam), //! current reconstruction parameters
fCorrMapCacheRef(transform.fCorrMapCacheRef),
fCorrMapCache0(transform.fCorrMapCache0),
fCorrMapCache1(transform.fCorrMapCache1),
fCurrentRun(transform.fCurrentRun), //! current run
Expand All @@ -126,6 +130,8 @@ AliTPCTransform::AliTPCTransform(const AliTPCTransform& transform):
fPrimVtx[1]=0;
fPrimVtx[2]=0;
fLastCorr[0]=fLastCorr[1]=fLastCorr[2] = 0;
fLastCorrRef[0]=fLastCorrRef[1]=fLastCorrRef[2] = 0;

}

AliTPCTransform::~AliTPCTransform() {
Expand Down Expand Up @@ -473,6 +479,10 @@ Bool_t AliTPCTransform::UpdateTimeDependentCache()
return fTimeDependentUpdated;
}
while (fCurrentRecoParam->GetUseCorrectionMap()) {
//
if (!fCorrMapCacheRef) { // need to load the reference correction map
LoadReferenceCorrectionMap();
}
//
if (fCorrMapCache0) {
// 1: easiest case: map is already cached, it is either time-static or there is
Expand All @@ -484,7 +494,7 @@ Bool_t AliTPCTransform::UpdateTimeDependentCache()
&& fCurrentTimeStamp>=fCorrMapCache0->GetTimeStampStart()) break;
}
else { // no map yet: 1st query
mapsArr = LoadCorrectionMaps();
mapsArr = LoadCorrectionMaps(kFALSE);
fCorrMapCache0 = (const AliTPCChebCorr*)mapsArr->UncheckedAt(0);
//
// 3: easy case: time-static map, fCorrMapCache1 is not neaded
Expand All @@ -501,7 +511,7 @@ Bool_t AliTPCTransform::UpdateTimeDependentCache()
}
}
// need to scan whole array to find matching maps
if (!mapsArr) mapsArr = LoadCorrectionMaps();
if (!mapsArr) mapsArr = LoadCorrectionMaps(kFALSE);
int nmaps = mapsArr->GetEntriesFast();
const AliTPCChebCorr* prv=0,*nxt=0;
for (int i=0;i<nmaps;i++) { // maps are ordered in time
Expand Down Expand Up @@ -552,6 +562,11 @@ Bool_t AliTPCTransform::UpdateTimeDependentCache()
fCorrMapCache1->Print();
}
}
if (fCorrMapCache0 && !fCorrMapCache0->IsCorrection())
AliFatalF("Uploaded map is not correction: %s",fCorrMapCache0->IsA()->GetName());
if (fCorrMapCache1 && !fCorrMapCache1->IsCorrection())
AliFatalF("Uploaded map is not correction: %s",fCorrMapCache1->IsA()->GetName());

if (fCorrMapCache0 && fCorrMapCache0->GetTimeStampStart()>fCurrentTimeStamp) {
AliWarningF("Event timestamp %ld < map0 beginning %ld",fCurrentTimeStamp,fCorrMapCache0->GetTimeStampStart());
fCorrMapCache0->Print();
Expand All @@ -568,31 +583,86 @@ Bool_t AliTPCTransform::UpdateTimeDependentCache()
}

//______________________________________________________
TObjArray* AliTPCTransform::LoadCorrectionMaps() const
void AliTPCTransform::LoadReferenceCorrectionMap()
{
// loads IR-independent reference correction map for relevan field polarity
//
const float kZeroField = 0.1;
TObjArray* mapsArr = LoadCorrectionMaps(kTRUE);
int entries = mapsArr->GetEntriesFast();
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField(); // think on extracting field once only
Double_t bzField = magF->SolenoidField(); //field in kGaus
Char_t expectType = AliTPCChebCorr::kFieldZero;
if (bzField<-kZeroField) expectType = AliTPCChebCorr::kFieldNeg;
else if (bzField> kZeroField) expectType = AliTPCChebCorr::kFieldPos;
//
fCorrMapCacheRef = 0;
for (int i=0;i<entries;i++) {
AliTPCChebCorr* map = (AliTPCChebCorr*)mapsArr->At(i); if (!map) continue;
if (!map->IsCorrection()) continue;
Char_t mtp = map->GetFieldType();
if (mtp==expectType || mtp==AliTPCChebCorr::kFieldAny) fCorrMapCacheRef = map;
if (mtp==expectType) break;
}
if (!fCorrMapCacheRef) AliFatal("Did not find reference correction map");

AliInfo("Loaded reference correction map");
fCorrMapCacheRef->Print();
if (fCorrMapCacheRef->GetFieldType() == AliTPCChebCorr::kFieldAny) {
AliWarningF("ATTENTION: no map for field %+.1f was found, placeholder map is used",bzField);
}
// fCorrMapCacheRef->SetTimeDependent(kFALSE);

// clean unnecessary stuff
mapsArr->Remove((TObject*)fCorrMapCacheRef);
mapsArr->SetOwner(kTRUE);
delete mapsArr;

}

//______________________________________________________
TObjArray* AliTPCTransform::LoadCorrectionMaps(Bool_t refMap) const
{
// TPC fast Chebyshev correction map, loaded on demand, not handler by calibDB
const char* kNameRef = "TPC/Calib/CorrectionMapsRef";
const char* kNameRun = "TPC/Calib/CorrectionMaps";
const char* mapTypeName = refMap ? kNameRef : kNameRun;
//
AliCDBManager* man = AliCDBManager::Instance();
AliCDBEntry* entry = man->Get("TPC/Calib/CorrectionMaps");
AliCDBEntry* entry = man->Get(mapTypeName);
TObjArray* correctionMaps = (TObjArray*)entry->GetObject();
for (int i=correctionMaps->GetEntriesFast();i--;) {
AliTPCChebCorr* map = (AliTPCChebCorr*)correctionMaps->At(i);
map->Init();
}
entry->SetOwner(0);
entry->SetObject(0);
man->UnloadFromCache("TPC/Calib/CorrectionMaps");
man->UnloadFromCache(mapTypeName);
return correctionMaps;
//
}

//______________________________________________________
void AliTPCTransform::EvalCorrectionMap(int roc, int row, const double xyz[3], float res[3])
void AliTPCTransform::ApplyCorrectionMap(int roc, int row, double xyzSect[3])
{
// apply correction from the map to a point at given ROC and row (IROC/OROC convention)
EvalCorrectionMap(roc, row, xyzSect, fLastCorrRef, kTRUE);
EvalCorrectionMap(roc, row, xyzSect, fLastCorr, kFALSE);
for (int i=3;i--;) xyzSect[i] += fLastCorr[i];
//
}

//______________________________________________________
void AliTPCTransform::EvalCorrectionMap(int roc, int row, const double xyz[3], float res[3], Bool_t ref)
{
// get correction from the map for a point at given ROC and row (IROC/OROC convention)
if (!fTimeDependentUpdated && !UpdateTimeDependentCache()) AliFatal("Failed to update time-dependent cache");
if (!fCorrMapCache0->IsCorrection()) AliFatalF("Uploaded map is not correction: %s",fCorrMapCache0->IsA()->GetName());
float y2x=xyz[1]/xyz[0], z2x = fCorrMapCache0->GetUseZ2R() ? xyz[2]/xyz[0] : xyz[2];
fCorrMapCache0->Eval(roc,row,y2x,z2x,res);

const AliTPCChebCorr* map = ref ? fCorrMapCacheRef : fCorrMapCache0;
float y2x=xyz[1]/xyz[0], z2x = map->GetUseZ2R() ? xyz[2]/xyz[0] : xyz[2];
map->Eval(roc,row,y2x,z2x,res);

if (ref) return; // this was time-independent query request
//
// for time dependent correction need to evaluate 2 maps, assuming linear dependence
if (fCorrMapCache1) {
Expand All @@ -608,14 +678,17 @@ void AliTPCTransform::EvalCorrectionMap(int roc, int row, const double xyz[3], f
}

//______________________________________________________
Float_t AliTPCTransform::EvalCorrectionMap(int roc, int row, const double xyz[3], int dimOut)
Float_t AliTPCTransform::EvalCorrectionMap(int roc, int row, const double xyz[3], int dimOut, Bool_t ref)
{
// get correction for dimOut-th dimension from the map for a point at given ROC and row (IROC/OROC convention)
if (!fTimeDependentUpdated && !UpdateTimeDependentCache()) AliFatal("Failed to update time-dependent cache");
if (!fCorrMapCache0->IsCorrection()) AliFatalF("Uploaded map is not correction: %s",fCorrMapCache0->IsA()->GetName());
float y2x=xyz[1]/xyz[0], z2x = fCorrMapCache0->GetUseZ2R() ? xyz[2]/xyz[0] : xyz[2];
float corr = fCorrMapCache0->Eval(roc,row,y2x,z2x,dimOut);

const AliTPCChebCorr* map = ref ? fCorrMapCacheRef : fCorrMapCache0;
float y2x=xyz[1]/xyz[0], z2x = map->GetUseZ2R() ? xyz[2]/xyz[0] : xyz[2];
float corr = map->Eval(roc,row,y2x,z2x,dimOut);
//
if (ref) return corr; // this was time-independent query request
//
// for time dependent correction need to evaluate 2 maps, assuming linear dependence
if (fCorrMapCache1) {
float corr1 = fCorrMapCache1->Eval(roc,row,y2x,z2x,dimOut);
Expand Down
20 changes: 8 additions & 12 deletions TPC/TPCbase/AliTPCTransform.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -34,10 +34,12 @@ class AliTPCTransform:public AliTransform {
const AliTPCRecoParam * GetCurrentRecoParam() const {return fCurrentRecoParam;}
AliTPCRecoParam * GetCurrentRecoParamNonConst() const {return fCurrentRecoParam;}
UInt_t GetCurrentRunNumber() const { return fCurrentRun;}
const AliTPCChebCorr* GetCorrMapCacheRef() const {return fCorrMapCacheRef;}
const AliTPCChebCorr* GetCorrMapCache0() const {return fCorrMapCache0;}
const AliTPCChebCorr* GetCorrMapCache1() const {return fCorrMapCache1;}
//
TObjArray* LoadCorrectionMaps() const;
TObjArray* LoadCorrectionMaps(Bool_t refMap=kFALSE) const;
void LoadReferenceCorrectionMap();
// set current values
//
void SetCurrentRecoParam(AliTPCRecoParam* param){fCurrentRecoParam=param;}
Expand All @@ -49,10 +51,11 @@ class AliTPCTransform:public AliTransform {
Bool_t UpdateTimeDependentCache();
void ApplyCorrectionMap(int roc, int row, double xyzSect[3]);
void ApplyDistortionMap(int roc, double xyzLab[3]);
void EvalCorrectionMap(int roc, int row, const double xyz[3], float res[3]);
Float_t EvalCorrectionMap(int roc, int row, const double xyz[3], int dimOut);
void EvalCorrectionMap(int roc, int row, const double xyz[3], float res[3], Bool_t ref=kFALSE);
Float_t EvalCorrectionMap(int roc, int row, const double xyz[3], int dimOut, Bool_t ref=kFALSE);
void EvalDistortionMap(int roc, const double xyzSector[3], float res[3]);
const Float_t* GetLastMapCorrection() const {return fLastCorr;}
const Float_t* GetLastMapCorrectionRef() const {return fLastCorrRef;}
//
static void RotateToSectorUp(float *x, int& idROC);
static void RotateToSectorDown(float *x, int& idROC);
Expand All @@ -65,10 +68,12 @@ class AliTPCTransform:public AliTransform {
private:
AliTPCTransform& operator=(const AliTPCTransform&); // not implemented
Float_t fLastCorr[3]; ///!<! last correction from the map
Float_t fLastCorrRef[3]; ///!<! last reference correction from the map
Double_t fCoss[18]; ///< cache the transformation
Double_t fSins[18]; ///< cache the transformation
Double_t fPrimVtx[3];///< position of the primary vertex - needed for TOF correction
AliTPCRecoParam * fCurrentRecoParam; //!<! current reconstruction parameters
const AliTPCChebCorr* fCorrMapCacheRef; //!<! reference (low-IR) correction map
const AliTPCChebCorr* fCorrMapCache0; //!<! current correction map0 (for 1st time bin if time-dependent)
const AliTPCChebCorr* fCorrMapCache1; //!<! current correction map1 (for 2nd time bin if time-dependent)
Int_t fCurrentRun; //!<! current run
Expand All @@ -83,15 +88,6 @@ class AliTPCTransform:public AliTransform {
/// \endcond
};

//______________________________________________________
inline void AliTPCTransform::ApplyCorrectionMap(int roc, int row, double xyzSect[3])
{
// apply correction from the map to a point at given ROC and row (IROC/OROC convention)
EvalCorrectionMap(roc, row, xyzSect, fLastCorr);
for (int i=3;i--;) xyzSect[i] += fLastCorr[i];
//
}

//_________________________________________________
inline void AliTPCTransform::RotateToSectorUp(float *x, int& idROC)
{
Expand Down
27 changes: 17 additions & 10 deletions TPC/TPCrec/AliTPCtracker.cxx
View file
Original file line number Diff line number Diff line change
Expand Up @@ -767,8 +767,8 @@ Double_t AliTPCtracker::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){
Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
Int_t ctype = cl->GetType();
Int_t type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
Double_t angle = seed->GetSnp()*seed->GetSnp();
angle = TMath::Sqrt(TMath::Abs(angle/(1.-angle)));
double angle2 = seed->GetSnp()*seed->GetSnp();
double angle = TMath::Sqrt(TMath::Abs(angle2/(1.f-angle2)));
Double_t erry2 = clparam->GetError0Par(0,type, z,angle);
if (ctype<0) {
erry2+=0.5; // edge cluster
Expand All @@ -778,16 +778,19 @@ Double_t AliTPCtracker::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){
const Double_t *errInner = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInner();
const Double_t *errInnerDeep = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInnerDeepY();
double dr = TMath::Abs(cl->GetX()-85.);
addErr=errInner[0]*TMath::Exp(-dr/errInner[1]);
if (errInner[0]>0) addErr=errInner[0]*TMath::Exp(-dr/errInner[1]);
if (errInnerDeep[0]>0) addErr += errInnerDeep[0]*TMath::Exp(-dr/errInnerDeep[1]);
erry2+=addErr*addErr;

const Double_t *errCluster = (AliTPCReconstructor::GetSystematicErrorCluster()) ? AliTPCReconstructor::GetSystematicErrorCluster() : AliTPCReconstructor::GetRecoParam()->GetSystematicErrorCluster();
erry2+=errCluster[0]*errCluster[0];
//
double useDist = AliTPCReconstructor::GetRecoParam()->GetUseDistortionFractionAsErrorY();
if (useDist>0) {
useDist *= cl->GetDistortionY();
erry2 += useDist*useDist;
float dstY = cl->GetDistortionY()*useDist;
float dstX = cl->GetDistortionX()*useDist;
float errDist2 = dstY*dstY +angle2*dstX*dstX;
erry2 += dstY*dstY +angle2*dstX*dstX;
}
seed->SetErrorY2(erry2);
//
Expand Down Expand Up @@ -933,7 +936,7 @@ Double_t AliTPCtracker::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){
Int_t ctype = cl->GetType();
Int_t type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2;
//
Double_t angle2 = seed->GetSnp()*seed->GetSnp();
double angle2 = seed->GetSnp()*seed->GetSnp();
angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2));
Double_t angle = TMath::Sqrt(TMath::Abs(angle2));
Double_t errz2 = clparam->GetError0Par(1,type, z,angle);
Expand All @@ -945,16 +948,17 @@ Double_t AliTPCtracker::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){
const Double_t *errInner = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInner();
const Double_t *errInnerDeepZ = AliTPCReconstructor::GetRecoParam()->GetSystematicErrorClusterInnerDeepZ();
double dr = TMath::Abs(cl->GetX()-85.);
addErr=errInner[0]*TMath::Exp(-dr/errInner[1]);
if (errInner[0]>0) addErr=errInner[0]*TMath::Exp(-dr/errInner[1]);
if (errInnerDeepZ[0]>0) addErr += errInnerDeepZ[0]*TMath::Exp(-dr/errInnerDeepZ[1]);
errz2+=addErr*addErr;
const Double_t *errCluster = (AliTPCReconstructor::GetSystematicErrorCluster()) ? AliTPCReconstructor::GetSystematicErrorCluster() : AliTPCReconstructor::GetRecoParam()->GetSystematicErrorCluster();
errz2+=errCluster[1]*errCluster[1];
//
double useDist = AliTPCReconstructor::GetRecoParam()->GetUseDistortionFractionAsErrorZ();
if (useDist>0) {
useDist *= cl->GetDistortionZ();
errz2 += useDist*useDist;
float dstZ = cl->GetDistortionZ()*useDist;
float dstX = cl->GetDistortionX()*useDist*seed->GetTgl();
errz2 += dstZ*dstZ+dstX*dstX;
}
seed->SetErrorZ2(errz2);
//
Expand Down Expand Up @@ -1987,7 +1991,10 @@ void AliTPCtracker::Transform(AliTPCclusterMI * cluster){
Int_t idROC = cluster->GetDetector();
transform->Transform(x,&idROC,0,1);
const float* clCorr = transform->GetLastMapCorrection();
cluster->SetDistortions(clCorr[0],clCorr[1],clCorr[2]); // memorize distortions
const float* clCorrRef = transform->GetLastMapCorrectionRef();
cluster->SetDistortions(clCorr[0]-clCorrRef[0],
clCorr[1]-clCorrRef[1],
clCorr[2]-clCorrRef[2]); // memorize distortions (difference to reference one)
//
// in debug mode check the transformation
//
Expand Down

0 comments on commit f86236f

Please sign in to comment.