X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCcalibDB.cxx;h=db440a3ed48f04b37b158dcc5615da1416a01be3;hb=556a6343f831c37d5f519ab7eb4fb4e152b530e8;hp=ec3e9bb3d1d1fb05702dc457eac5c3e0ec47a623;hpb=d32e86769bde26a1536e87840ffe1e659aab07a5;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCcalibDB.cxx b/TPC/AliTPCcalibDB.cxx index ec3e9bb3d1d..db440a3ed48 100644 --- a/TPC/AliTPCcalibDB.cxx +++ b/TPC/AliTPCcalibDB.cxx @@ -99,6 +99,7 @@ #include "AliTPCSensorTempArray.h" #include "AliGRPObject.h" #include "AliTPCTransform.h" +#include "AliTPCmapper.h" class AliCDBStorage; class AliTPCCalDet; @@ -113,6 +114,7 @@ class AliTPCCalDet; #include "TObjString.h" #include "TString.h" #include "TDirectory.h" +#include "TArrayI.h" #include "AliTPCCalPad.h" #include "AliTPCCalibPulser.h" #include "AliTPCCalibPedestal.h" @@ -122,7 +124,8 @@ class AliTPCCalDet; #include "AliTPCCalibVdrift.h" #include "AliTPCCalibRaw.h" #include "AliTPCParam.h" - +#include "AliTPCCorrection.h" +#include "AliTPCComposedCorrection.h" #include "AliTPCPreprocessorOnline.h" @@ -176,6 +179,9 @@ AliTPCcalibDB::AliTPCcalibDB(): fPadGainFactor(0), fDedxGainFactor(0), fPadTime0(0), + fDistortionMap(0), + fComposedCorrection(0), + fComposedCorrectionArray(0), fPadNoise(0), fPedestals(0), fCalibRaw(0), @@ -197,13 +203,16 @@ AliTPCcalibDB::AliTPCcalibDB(): fVdriftArray(100000), //! array of v drift interfaces fDriftCorrectionArray(100000), //! array of drift correction fRunList(100000), //! run list - indicates try to get the run param + fBHasAlignmentOCDB(kFALSE), // Flag - has the alignment on the composed correction ? fDButil(0), - fCTPTimeParams(0) + fCTPTimeParams(0), + fMode(-1) { // // constructor // // + fgInstance=this; Update(); // temporary } @@ -215,6 +224,9 @@ AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ): fPadGainFactor(0), fDedxGainFactor(0), fPadTime0(0), + fDistortionMap(0), + fComposedCorrection(0), + fComposedCorrectionArray(0), fPadNoise(0), fPedestals(0), fCalibRaw(0), @@ -234,10 +246,12 @@ AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ): fVoltageArray(0), fTemperatureArray(0), //! array of temperature sensors - per run - Just for calibration studies fVdriftArray(0), //! array of v drift interfaces - fDriftCorrectionArray(0), //! array of v drift interfaces + fDriftCorrectionArray(0), //! array of v drift corrections fRunList(0), //! run list - indicates try to get the run param + fBHasAlignmentOCDB(kFALSE), // Flag - has the alignment on the composed correction ? fDButil(0), - fCTPTimeParams(0) + fCTPTimeParams(0), + fMode(-1) { // // Copy constructor invalid -- singleton implementation @@ -263,12 +277,13 @@ AliTPCcalibDB::~AliTPCcalibDB() // destructor // - // don't delete anything, CDB cache is active! - //if (fPadGainFactor) delete fPadGainFactor; - //if (fPadTime0) delete fPadTime0; - //if (fPadNoise) delete fPadNoise; } - +AliTPCCalPad* AliTPCcalibDB::GetDistortionMap(Int_t i) const { + // + // get distortion map - due E field distortions + // + return (fDistortionMap) ? (AliTPCCalPad*)fDistortionMap->At(i):0; +} //_____________________________________________________________________________ AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath) @@ -281,7 +296,7 @@ AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath) AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun); if (!entry) { - sprintf(chinfo,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath); + snprintf(chinfo,1000,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath); AliError(chinfo); return 0; } @@ -304,17 +319,23 @@ void AliTPCcalibDB::SetRun(Long64_t run) void AliTPCcalibDB::Update(){ - // + // + // cache the OCDB entries for simulation, reconstruction, calibration + // + // AliCDBEntry * entry=0; Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache fDButil = new AliTPCcalibDButil; // + entry = GetCDBEntry("TPC/Calib/PadGainFactor"); if (entry){ //if (fPadGainFactor) delete fPadGainFactor; entry->SetOwner(kTRUE); fPadGainFactor = (AliTPCCalPad*)entry->GetObject(); + }else{ + AliFatal("TPC - Missing calibration entry TPC/Calib/PadGainFactor"); } // entry = GetCDBEntry("TPC/Calib/TimeGain"); @@ -322,12 +343,16 @@ void AliTPCcalibDB::Update(){ //if (fTimeGainSplines) delete fTimeGainSplines; entry->SetOwner(kTRUE); fTimeGainSplines = (TObjArray*)entry->GetObject(); + }else{ + AliFatal("TPC - Missing calibration entry TPC/Calib/Timegain"); } // entry = GetCDBEntry("TPC/Calib/GainFactorDedx"); if (entry){ entry->SetOwner(kTRUE); fDedxGainFactor = (AliTPCCalPad*)entry->GetObject(); + }else{ + AliFatal("TPC - Missing calibration entry TPC/Calib/gainFactordEdx"); } // entry = GetCDBEntry("TPC/Calib/PadTime0"); @@ -335,7 +360,20 @@ void AliTPCcalibDB::Update(){ //if (fPadTime0) delete fPadTime0; entry->SetOwner(kTRUE); fPadTime0 = (AliTPCCalPad*)entry->GetObject(); + }else{ + AliFatal("TPC - Missing calibration entry"); } + + entry = GetCDBEntry("TPC/Calib/Distortion"); + if (entry){ + //if (fPadTime0) delete fPadTime0; + entry->SetOwner(kTRUE); + fDistortionMap =dynamic_cast(entry->GetObject()); + }else{ + //AliFatal("TPC - Missing calibration entry") + } + + // // entry = GetCDBEntry("TPC/Calib/PadNoise"); @@ -343,6 +381,8 @@ void AliTPCcalibDB::Update(){ //if (fPadNoise) delete fPadNoise; entry->SetOwner(kTRUE); fPadNoise = (AliTPCCalPad*)entry->GetObject(); + }else{ + AliFatal("TPC - Missing calibration entry"); } entry = GetCDBEntry("TPC/Calib/Pedestals"); @@ -364,12 +404,16 @@ void AliTPCcalibDB::Update(){ //if (fPadNoise) delete fPadNoise; entry->SetOwner(kTRUE); fParam = (AliTPCParam*)(entry->GetObject()->Clone()); + }else{ + AliFatal("TPC - Missing calibration entry TPC/Calib/Parameters"); } entry = GetCDBEntry("TPC/Calib/ClusterParam"); if (entry){ entry->SetOwner(kTRUE); fClusterParam = (AliTPCClusterParam*)(entry->GetObject()->Clone()); + }else{ + AliFatal("TPC - Missing calibration entry"); } //ALTRO configuration data @@ -377,6 +421,8 @@ void AliTPCcalibDB::Update(){ if (entry){ entry->SetOwner(kTRUE); fALTROConfigData=(TObjArray*)(entry->GetObject()); + }else{ + AliFatal("TPC - Missing calibration entry"); } //Calibration Pulser data @@ -393,18 +439,7 @@ void AliTPCcalibDB::Update(){ fCEData=(TObjArray*)(entry->GetObject()); } //RAW calibration data - entry = GetCDBEntry("TPC/Calib/Raw"); - if (entry){ - entry->SetOwner(kTRUE); - TObjArray *arr=(TObjArray*)(entry->GetObject()); - if (arr) fCalibRaw=(AliTPCCalibRaw*)arr->At(0); - } - //QA calibration data - entry = GetCDBEntry("TPC/Calib/QA"); - if (entry){ - entry->SetOwner(kTRUE); - fDataQA=dynamic_cast(entry->GetObject()); - } + // entry = GetCDBEntry("TPC/Calib/Raw"); entry = GetCDBEntry("TPC/Calib/Mapping"); if (entry){ @@ -419,33 +454,81 @@ void AliTPCcalibDB::Update(){ } } - //QA calibration data + //CTP calibration data entry = GetCDBEntry("GRP/CTP/CTPtiming"); if (entry){ //entry->SetOwner(kTRUE); fCTPTimeParams=dynamic_cast(entry->GetObject()); - } - - - //entry = GetCDBEntry("TPC/Calib/ExB"); - //if (entry) { - // entry->SetOwner(kTRUE); - // fExB=dynamic_cast(entry->GetObject()->Clone()); - //} + }else{ + AliError("TPC - Missing calibration entry"); + } + //TPC space point correction data + entry = GetCDBEntry("TPC/Calib/Correction"); + if (entry){ + //entry->SetOwner(kTRUE); + fComposedCorrection=dynamic_cast(entry->GetObject()); + if (fComposedCorrection) fComposedCorrection->Init(); + fComposedCorrectionArray=dynamic_cast(entry->GetObject()); + if (fComposedCorrectionArray){ + for (Int_t i=0; iGetEntries(); i++){ + AliTPCComposedCorrection* composedCorrection= dynamic_cast(fComposedCorrectionArray->At(i)); + if (composedCorrection) { + composedCorrection->Init(); + if (composedCorrection->GetCorrections()){ + if (composedCorrection->GetCorrections()->FindObject("FitAlignTPC")){ + fBHasAlignmentOCDB=kTRUE; + } + } + } + } + } + }else{ + AliError("TPC - Missing calibration entry- TPC/Calib/Correction"); + } + //RCU trigger config mode + fMode=GetRCUTriggerConfig(); // - // ExB - calculate during initialization - in simulation /reconstruction - // - not invoked here anymore - //fExB = GetExB(-5,kTRUE); - // if (!fTransform) { fTransform=new AliTPCTransform(); fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun()); } + // Create Dead Channel Map + InitDeadMap(); + // AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache } +void AliTPCcalibDB::UpdateNonRec(){ + // + // Update/Load the parameters which are important for QA studies + // and not used yet for the reconstruction + // + //RAW calibration data + AliCDBEntry * entry=0; + entry = GetCDBEntry("TPC/Calib/Raw"); + if (entry){ + entry->SetOwner(kTRUE); + TObjArray *arr=(TObjArray*)(entry->GetObject()); + if (arr) fCalibRaw=(AliTPCCalibRaw*)arr->At(0); + } + //QA calibration data + entry = GetCDBEntry("TPC/Calib/QA"); + if (entry){ + entry->SetOwner(kTRUE); + fDataQA=dynamic_cast(entry->GetObject()); + } + // High voltage + if (fRun>=0){ + entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",fRun); + if (entry) { + fVoltageArray.AddAt(entry->GetObject(),fRun); + } + } + +} + void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects) @@ -540,7 +623,15 @@ void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObj } } +Int_t AliTPCcalibDB::InitDeadMap() { + // Initialize DeadChannel Map + // Source of information: + // - HV < HVnominal -delta + // - Altro disabled channels. Noisy channels. + // - DDL list + return 0; +} void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) { // @@ -774,9 +865,8 @@ Bool_t AliTPCcalibDB::IsTrgL0() // // return if the FEE readout was triggered on L0 // - Int_t mode=GetRCUTriggerConfig(); - if (mode<0) return kFALSE; - return (mode==1); + if (fMode<0) return kFALSE; + return (fMode==1); } Bool_t AliTPCcalibDB::IsTrgL1() @@ -784,9 +874,8 @@ Bool_t AliTPCcalibDB::IsTrgL1() // // return if the FEE readout was triggered on L1 // - Int_t mode=GetRCUTriggerConfig(); - if (mode<0) return kFALSE; - return (mode==0); + if (fMode<0) return kFALSE; + return (fMode==0); } void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){ @@ -851,7 +940,8 @@ void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){ // // - > Don't use it for reconstruction - Only for Calibration studies // - if (run<0) return; + if (run<=0) return; + fRun=run; AliCDBEntry * entry = 0; if (run>= fRunList.fN){ fRunList.Set(run*2+1); @@ -896,19 +986,27 @@ void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){ fGoofieArray.AddAt(entry->GetObject(),run); } // - entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",run); - if (entry) { - fVoltageArray.AddAt(entry->GetObject(),run); - } + // entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGain",run); if (entry) { fTimeGainSplinesArray.AddAt(entry->GetObject(),run); + }else{ + AliFatal("TPC - Missing calibration entry TimeGain"); } // entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeDrift",run); if (entry) { - fDriftCorrectionArray.AddAt(entry->GetObject(),run); + TObjArray * timeArray = (TObjArray*)entry->GetObject(); + fDriftCorrectionArray.AddAt(entry->GetObject(),run); + AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime"); + if (correctionTime && fComposedCorrectionArray){ + correctionTime->Init(); + if (fComposedCorrectionArray->GetEntriesFast()<4) fComposedCorrectionArray->Expand(40); + fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent correction to the list of available corrections + } + }else{ + AliFatal("TPC - Missing calibration entry TimeDrift"); } // entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run); @@ -927,24 +1025,28 @@ void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){ accept = fDButil->FilterTemperature(temp)>0.1; } if (press) { - const Double_t kMinP=950.; + const Double_t kMinP=900.; const Double_t kMaxP=1050.; const Double_t kMaxdP=10.; const Double_t kSigmaCut=4.; fDButil->FilterSensor(press,kMinP,kMaxP,kMaxdP,kSigmaCut); if (press->GetFit()==0) accept=kFALSE; } + if (press && temp &&accept){ AliTPCCalibVdrift * vdrift = new AliTPCCalibVdrift(temp, press,0); fVdriftArray.AddAt(vdrift,run); } + fDButil->FilterCE(120., 3., 4.,0); fDButil->FilterTracks(run, 10.,0); + } Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){ // + // Get Gain factor for given pad // AliTPCCalPad *calPad = Instance()->fDedxGainFactor;; if (!calPad) return 0; @@ -953,7 +1055,7 @@ Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){ AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){ // - // + // GetDrift velocity spline fit // TObjArray *arr=GetTimeVdriftSplineRun(run); if (!arr) return 0; @@ -980,6 +1082,9 @@ AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){ // // Get GRP object for given run // + if (run>= ((Instance()->fGRPArray)).GetEntriesFast()){ + Instance()->UpdateRunInformations(run); + } AliGRPObject * grpRun = dynamic_cast((Instance()->fGRPArray).At(run)); if (!grpRun) { Instance()->UpdateRunInformations(run); @@ -991,7 +1096,7 @@ AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){ TMap * AliTPCcalibDB::GetGRPMap(Int_t run){ // - // + // Get GRP map for given run // TMap * grpRun = dynamic_cast((Instance()->fGRPMaps).At(run)); if (!grpRun) { @@ -1103,6 +1208,7 @@ AliTPCCalibVdrift * AliTPCcalibDB::GetVdrift(Int_t run){ // // Get the interface to the the vdrift // + if (run>=fVdriftArray.GetEntriesFast()) UpdateRunInformations(run); AliTPCCalibVdrift * vdrift = (AliTPCCalibVdrift*)fVdriftArray.At(run); if (!vdrift) { UpdateRunInformations(run); @@ -1239,14 +1345,14 @@ Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char } } if (sigDigits>=0){ - val/=10; + // val/=10; val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits); - val*=10; + // val*=10; } return val; } -Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) { +Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits, Bool_t current) { // // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC // if timeStamp==-1 return mean value @@ -1265,6 +1371,16 @@ Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t time //OROC sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,sector%18); } + if (current){ + if (sector<36){ + //IROC + sensorName=Form("TPC_ANODE_I_%c%02d_IMEAS",sideName,sector%18); + }else{ + //OROC + sensorName=Form("TPC_ANODE_O_%c%02d_0_IMEAS",sideName,sector%18); + } + + } if (timeStamp==-1){ val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); } else { @@ -1481,7 +1597,7 @@ Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){ Bool_t AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){ // - // + // GetTmeparature fit at parameter for given time stamp // TTimeStamp tstamp(timeStamp); AliTPCSensorTempArray* tempArray = Instance()->GetTemperatureSensor(run); @@ -1500,8 +1616,8 @@ Bool_t AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side, Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){ // - // - // + // Get mean temperature + // TVectorD vec(5); if (side==0) { GetTemperatureFit(timeStamp,run,0,vec); @@ -1553,6 +1669,7 @@ AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){ AliGRPObject *grpRun = new AliGRPObject; grpRun->ReadValuesFromMap(map); grpRun->SetCavernAtmosPressure(sensor2); + grpRun->SetCavernAtmosPressure(sensor2); grpRun->SetSurfaceAtmosPressure(sensor); return grpRun; } @@ -1584,7 +1701,8 @@ Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){ AliError("Default Storage not set. Cannot create calibration Tree!"); return kFALSE; } - + UpdateNonRec(); // load all infromation now + AliTPCPreprocessorOnline prep; //noise and pedestals if (GetPedestals()) prep.AddComponent(new AliTPCCalPad(*(GetPedestals()))); @@ -1624,7 +1742,7 @@ Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){ // TString file(filename); - if (file.IsNull()) file=Form("guiTreeRun_%d.root",fRun); + if (file.IsNull()) file=Form("guiTreeRun_%lld.root",fRun); prep.DumpToFile(file.Data()); return kTRUE; } @@ -1686,7 +1804,7 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_ // // Notice - Extrapolation outside of calibration range - using constant function // - Double_t result; + Double_t result=0; // mode 1 automatic mode - according to the distance to the valid calibration // - Double_t deltaP=0, driftP=0, wP = 0.; @@ -1704,6 +1822,9 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_ if (mode==1) { const Double_t kEpsilon=0.00000000001; const Double_t kdeltaT=360.; // 10 minutes + if(TMath::Abs(deltaITS) < 12*kdeltaT) { + result = driftITS; + } else { wITS = 64.*kdeltaT/(deltaITS +kdeltaT); wLT = 16.*kdeltaT/(deltaLT +kdeltaT); wP = 0. *kdeltaT/(deltaP +kdeltaT); @@ -1716,6 +1837,9 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_ if (TMath::Abs(driftCE)GetTimeVdriftSplineRun(run); if (!array) return 0; + Double_t result=0; + + // use TPC-ITS if present + TGraphErrors *gr= (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_VDGY"); + if(gr) { + result = AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); + + // transform from [(cm/mus)/ m] to [1/cm] + result /= (fParam->GetDriftV()/1000000.); + result /= 100.; + + //printf("result %e \n", result); + return result; + } + + // use laser if ITS-TPC not present TGraphErrors *laserA= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A"); TGraphErrors *laserC= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C"); - Double_t result=0; if (laserA && laserC){ result= (laserA->Eval(timeStamp)+laserC->Eval(timeStamp))*0.5; } @@ -1782,8 +1921,127 @@ Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t if (laserC &&side==1){ result = (laserC->Eval(timeStamp)); } + //printf("laser result %e \n", -result/250.); + return -result/250.; //normalized before } +AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMappingFile) { +// +// Read list of active DDLs from OCDB entry +// Generate and return AliTPCCalPad containing 1 for all pads in active DDLs, +// 0 for all pads in non-active DDLs. +// For DDLs with missing status information (no DCS input point to Shuttle), +// the value of the AliTPCCalPad entry is determined by the parameter +// notInMap (default value 1) +// + char chinfo[1000]; + + TFile *fileMapping = new TFile(nameMappingFile, "read"); + AliTPCmapper *mapping = (AliTPCmapper*) fileMapping->Get("tpcMapping"); + if (!mapping) { + snprintf(chinfo,1000,"Failed to get mapping object from %s. ...\n", nameMappingFile); + AliError (chinfo); + return 0; + } + + AliTPCCalPad *deadMap = new AliTPCCalPad("deadMap","deadMap"); + if (!deadMap) { + AliError("Failed to allocate dead map AliTPCCalPad"); + return 0; + } + + /// get list of active DDLs from OCDB entry + Int_t idDDL=0; + if (!fALTROConfigData ) { + AliError("No ALTRO config OCDB entry available"); + return 0; + } + TMap *activeDDL = (TMap*)fALTROConfigData->FindObject("DDLArray"); + TObjString *ddlArray=0; + if (activeDDL) { + ddlArray = (TObjString*)activeDDL->GetValue("DDLArray"); + if (!ddlArray) { + AliError("Empty list of active DDLs in OCDB entry"); + return 0; + } + } else { + AliError("List of active DDLs not available in OCDB entry"); + return 0; + } + TString arrDDL=ddlArray->GetString(); + Int_t offset = mapping->GetTpcDdlOffset(); + Double_t active; + for (Int_t i=0; iGetNumDdl(); i++) { + idDDL= i+offset; + if (idDDL<0) continue; + Int_t patch = mapping->GetPatchFromEquipmentID(idDDL); + if (patch<0) continue; + Int_t roc=mapping->GetRocFromEquipmentID(idDDL); + if (roc<0) continue; + AliTPCCalROC *calRoc=deadMap->GetCalROC(roc); + if (calRoc) { + for ( Int_t branch = 0; branch < 2; branch++ ) { + for ( Int_t fec = 0; fec < mapping->GetNfec(patch, branch); fec++ ) { + for ( Int_t altro = 0; altro < 8; altro++ ) { + for ( Int_t channel = 0; channel < 16; channel++ ) { + Int_t hwadd = mapping->CodeHWAddress(branch, fec, altro, channel); + Int_t row = mapping->GetPadRow(patch, hwadd); // row in a ROC (IROC or OROC) +// Int_t globalrow = mapping.GetGlobalPadRow(patch, hwadd); // row in full sector (IROC plus OROC) + Int_t pad = mapping->GetPad(patch, hwadd); + if (!TString(arrDDL[i]).IsDigit()) { + active = notInMap; + } else { + active=TString(arrDDL[i]).Atof(); + } + calRoc->SetValue(row,pad,active); + } // end channel for loop + } // end altro for loop + } // end fec for loop + } // end branch for loop + } // valid calROC + } // end loop on active DDLs + return deadMap; +} + + + +AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{ + // + // GetComposed correction for given field setting + // If not specific correction for field used return correction for all field + // - Complication needed to gaurantee OCDB back compatibility + // - Not neeeded for the new space point correction + if (!fComposedCorrectionArray) return 0; + if (field>0.1 && fComposedCorrectionArray->At(1)) { + return (AliTPCCorrection *)fComposedCorrectionArray->At(1); + } + if (field<-0.1 &&fComposedCorrectionArray->At(2)) { + return (AliTPCCorrection *)fComposedCorrectionArray->At(2); + } + return (AliTPCCorrection *)fComposedCorrectionArray->At(0); + +} + +AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{ + // + // GetComposedCorrection delta + // Delta is time dependent - taken form the CalibTime OCDB entry + // + if (!fComposedCorrectionArray) return 0; + if (fRun<0) return 0; + if (fDriftCorrectionArray.GetEntriesFast()<=fRun) return 0; + if (fDriftCorrectionArray.At(fRun)==0) return 0; + if (fComposedCorrectionArray->GetEntriesFast()<=4) { + fComposedCorrectionArray->Expand(5); + TObjArray * timeArray =(TObjArray*)(fDriftCorrectionArray.At(fRun)); + AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime"); + if (correctionTime){ + correctionTime->Init(); + fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent c + } + } + return (AliTPCCorrection *)fComposedCorrectionArray->At(4); // +}