X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCcalibDB.cxx;h=b2c520ba3cc394793efcc14dfd51cfb38980fb9b;hb=7c6ab170e1756338962895b6526abbc562b2b532;hp=eef7cb91f897fb6bfc43fcf5ef2d65514a59e131;hpb=96305e49cd4437a18c7e4a6391e0861dafe5241e;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCcalibDB.cxx b/TPC/AliTPCcalibDB.cxx index eef7cb91f89..b2c520ba3cc 100644 --- a/TPC/AliTPCcalibDB.cxx +++ b/TPC/AliTPCcalibDB.cxx @@ -82,16 +82,24 @@ #include #include +#include #include +#include +#include +#include #include "AliTPCcalibDB.h" +#include "AliTPCdataQA.h" +#include "AliTPCcalibDButil.h" #include "AliTPCAltroMapping.h" #include "AliTPCExB.h" #include "AliTPCCalROC.h" #include "AliTPCCalPad.h" #include "AliTPCSensorTempArray.h" +#include "AliGRPObject.h" #include "AliTPCTransform.h" +#include "AliTPCmapper.h" class AliCDBStorage; class AliTPCCalDet; @@ -100,23 +108,32 @@ class AliTPCCalDet; #include "TFile.h" #include "TKey.h" +#include "TGraphErrors.h" #include "TObjArray.h" #include "TObjString.h" #include "TString.h" +#include "TDirectory.h" +#include "TArrayI.h" #include "AliTPCCalPad.h" #include "AliTPCCalibPulser.h" #include "AliTPCCalibPedestal.h" #include "AliTPCCalibCE.h" - - - +#include "AliTPCExBFirst.h" +#include "AliTPCTempMap.h" +#include "AliTPCCalibVdrift.h" +#include "AliTPCCalibRaw.h" +#include "AliTPCParam.h" +#include "AliTPCCorrection.h" +#include "AliTPCComposedCorrection.h" +#include "AliTPCPreprocessorOnline.h" ClassImp(AliTPCcalibDB) AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0; Bool_t AliTPCcalibDB::fgTerminated = kFALSE; +TObjArray AliTPCcalibDB::fgExBArray; // array of ExB corrections //_ singleton implementation __________________________________________________ @@ -155,25 +172,104 @@ void AliTPCcalibDB::Terminate() //_____________________________________________________________________________ AliTPCcalibDB::AliTPCcalibDB(): + TObject(), fRun(-1), fTransform(0), fExB(0), fPadGainFactor(0), + fDedxGainFactor(0), fPadTime0(0), + fDistortionMap(0), + fComposedCorrection(0), + fComposedCorrectionArray(0), fPadNoise(0), fPedestals(0), + fCalibRaw(0), + fDataQA(0), + fALTROConfigData(0), + fPulserData(0), + fCEData(0), fTemperature(0), fMapping(0), fParam(0), - fClusterParam(0) + fClusterParam(0), + fTimeGainSplines(0), + fTimeGainSplinesArray(100000), + fGRPArray(100000), //! array of GRPs - per run - JUST for calibration studies + fGRPMaps(100000), //! array of GRPs - per run - JUST for calibration studies + fGoofieArray(100000), //! array of GOOFIE values -per run - Just for calibration studies + fVoltageArray(100000), + fTemperatureArray(100000), //! array of temperature sensors - per run - Just for calibration studies + 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), + fMode(-1) { // // constructor // // + fgInstance=this; Update(); // temporary } +AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ): + TObject(), + fRun(-1), + fTransform(0), + fExB(0), + fPadGainFactor(0), + fDedxGainFactor(0), + fPadTime0(0), + fDistortionMap(0), + fComposedCorrection(0), + fComposedCorrectionArray(0), + fPadNoise(0), + fPedestals(0), + fCalibRaw(0), + fDataQA(0), + fALTROConfigData(0), + fPulserData(0), + fCEData(0), + fTemperature(0), + fMapping(0), + fParam(0), + fClusterParam(0), + fTimeGainSplines(0), + fTimeGainSplinesArray(100000), + fGRPArray(0), //! array of GRPs - per run - JUST for calibration studies + fGRPMaps(0), //! array of GRPs - per run - JUST for calibration studies + fGoofieArray(0), //! array of GOOFIE values -per run - Just for calibration studies + 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 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), + fMode(-1) +{ + // + // Copy constructor invalid -- singleton implementation + // + Error("copy constructor","invalid -- singleton implementation"); +} + +AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& ) +{ +// +// Singleton implementation - no assignment operator +// + Error("operator =", "assignment operator not implemented"); + return *this; +} + + + //_____________________________________________________________________________ AliTPCcalibDB::~AliTPCcalibDB() { @@ -181,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) @@ -199,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; } @@ -215,25 +312,47 @@ void AliTPCcalibDB::SetRun(Long64_t run) // if (fRun == run) return; - fRun = run; + fRun = run; Update(); } 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"); + if (entry){ + //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"); @@ -241,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"); @@ -249,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"); @@ -270,15 +404,43 @@ 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){ - //if (fPadNoise) delete fPadNoise; entry->SetOwner(kTRUE); fClusterParam = (AliTPCClusterParam*)(entry->GetObject()->Clone()); + }else{ + AliFatal("TPC - Missing calibration entry"); } + //ALTRO configuration data + entry = GetCDBEntry("TPC/Calib/AltroConfig"); + if (entry){ + entry->SetOwner(kTRUE); + fALTROConfigData=(TObjArray*)(entry->GetObject()); + }else{ + AliFatal("TPC - Missing calibration entry"); + } + + //Calibration Pulser data + entry = GetCDBEntry("TPC/Calib/Pulser"); + if (entry){ + entry->SetOwner(kTRUE); + fPulserData=(TObjArray*)(entry->GetObject()); + } + + //CE data + entry = GetCDBEntry("TPC/Calib/CE"); + if (entry){ + entry->SetOwner(kTRUE); + fCEData=(TObjArray*)(entry->GetObject()); + } + //RAW calibration data + // entry = GetCDBEntry("TPC/Calib/Raw"); + entry = GetCDBEntry("TPC/Calib/Mapping"); if (entry){ //if (fPadNoise) delete fPadNoise; @@ -287,42 +449,81 @@ void AliTPCcalibDB::Update(){ if (array && array->GetEntriesFast()==6){ fMapping = new AliTPCAltroMapping*[6]; for (Int_t i=0; i<6; i++){ - fMapping[i] = dynamic_cast(array->At(i)); + fMapping[i] = dynamic_cast(array->At(i)); } } } - - - entry = GetCDBEntry("TPC/Calib/ExB"); - if (entry) { - entry->SetOwner(kTRUE); - fExB=dynamic_cast(entry->GetObject()->Clone()); - } - + //CTP calibration data + entry = GetCDBEntry("GRP/CTP/CTPtiming"); + if (entry){ + //entry->SetOwner(kTRUE); + fCTPTimeParams=dynamic_cast(entry->GetObject()); + }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(); + // if (!fTransform) { fTransform=new AliTPCTransform(); + fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun()); } // AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache - } -AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& org) -{ + +void AliTPCcalibDB::UpdateNonRec(){ // - // Copy constructor invalid -- singleton implementation + // Update/Load the parameters which are important for QA studies + // and not used yet for the reconstruction // - Error("copy constructor","invalid -- singleton implementation"); -} + //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); + } + } -AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& rhs) -{ -// -// Singleton implementation - no assignment operator -// - Error("operator =", "assignment operator not implemented"); - return *this; } @@ -351,7 +552,7 @@ void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObj TIter nextLine(arrFileLine); TObjString *sObjLine=0x0; - while ( sObjLine = (TObjString*)nextLine() ){ + while ( (sObjLine = (TObjString*)nextLine()) ){ TString sLine(sObjLine->GetString()); TObjArray *arrNextCol = sLine.Tokenize("\t"); @@ -629,3 +830,1207 @@ void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const cha } } +Int_t AliTPCcalibDB::GetRCUTriggerConfig() const +{ + // + // return the RCU trigger configuration register + // + TMap *map=GetRCUconfig(); + if (!map) return -1; + TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE"); + Float_t mode=-1; + for (Int_t i=0; iGetNrows(); ++i){ + Float_t newmode=v->GetMatrixArray()[i]; + if (newmode>-1){ + if (mode>-1&&newmode!=mode) AliWarning("Found different RCU trigger configurations!!!"); + mode=newmode; + } + } + return (Int_t)mode; +} + +Bool_t AliTPCcalibDB::IsTrgL0() +{ + // + // return if the FEE readout was triggered on L0 + // + if (fMode<0) return kFALSE; + return (fMode==1); +} + +Bool_t AliTPCcalibDB::IsTrgL1() +{ + // + // return if the FEE readout was triggered on L1 + // + if (fMode<0) return kFALSE; + return (fMode==0); +} + +void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){ + // + // Register static ExB correction map + // index - registration index - used for visualization + // bz - bz field in kGaus + + // Float_t factor = bz/(-5.); // default b filed in Cheb with minus sign + Float_t factor = bz/(5.); // default b filed in Cheb with minus sign + // was chenged in the Revision ???? (Ruben can you add here number) + + AliMagF* bmap = new AliMagF("MapsExB","MapsExB", factor,TMath::Sign(1.f,factor),AliMagF::k5kG); + + AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50); + AliTPCExB::SetInstance(exb); + + if (bdelete){ + delete bmap; + }else{ + AliTPCExB::RegisterField(index,bmap); + } + if (index>=fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11); + fgExBArray.AddAt(exb,index); +} + + +AliTPCExB* AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) { + // + // bz filed in KGaus not in tesla + // Get ExB correction map + // if doesn't exist - create it + // + Int_t index = TMath::Nint(5+bz); + if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11); + if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB); + return (AliTPCExB*)fgExBArray.At(index); +} + + +void AliTPCcalibDB::SetExBField(Float_t bz){ + // + // Set magnetic filed for ExB correction + // + fExB = GetExB(bz,kFALSE); +} + +void AliTPCcalibDB::SetExBField(const AliMagF* bmap){ + // + // Set magnetic field for ExB correction + // + AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50); + AliTPCExB::SetInstance(exb); + fExB=exb; +} + + + + + +void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){ + // + // - > Don't use it for reconstruction - Only for Calibration studies + // + if (run<=0) return; + fRun=run; + AliCDBEntry * entry = 0; + if (run>= fRunList.fN){ + fRunList.Set(run*2+1); + fGRPArray.Expand(run*2+1); + fGRPMaps.Expand(run*2+1); + fGoofieArray.Expand(run*2+1); + fVoltageArray.Expand(run*2+1); + fTemperatureArray.Expand(run*2+1); + fVdriftArray.Expand(run*2+1); + fDriftCorrectionArray.Expand(run*2+1); + fTimeGainSplinesArray.Expand(run*2+1); + // + // + fALTROConfigData->Expand(run*2+1); // ALTRO configuration data + fPulserData->Expand(run*2+1); // Calibration Pulser data + fCEData->Expand(run*2+1); // CE data + if (!fTimeGainSplines) fTimeGainSplines = new TObjArray(run*2+1); + fTimeGainSplines->Expand(run*2+1); // Array of AliSplineFits: at 0 MIP position in + } + if (fRunList[run]>0 &&force==kFALSE) return; + + fRunList[run]=1; // sign as used + + // + entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run); + if (entry) { + AliGRPObject * grpRun = dynamic_cast(entry->GetObject()); + if (!grpRun){ + TMap* map = dynamic_cast(entry->GetObject()); + if (map){ + //grpRun = new AliGRPObject; + //grpRun->ReadValuesFromMap(map); + grpRun = MakeGRPObjectFromMap(map); + + fGRPMaps.AddAt(map,run); + } + } + fGRPArray.AddAt(grpRun,run); + } + entry = AliCDBManager::Instance()->Get("TPC/Calib/Goofie",run); + if (entry){ + fGoofieArray.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) { + 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); + if (entry) { + fTemperatureArray.AddAt(entry->GetObject(),run); + } + //apply fDButil filters + + fDButil->UpdateFromCalibDB(); + if (fTemperature) fDButil->FilterTemperature(fTemperature); + + AliDCSSensor * press = GetPressureSensor(run,0); + AliTPCSensorTempArray * temp = GetTemperatureSensor(run); + Bool_t accept=kTRUE; + if (temp) { + accept = fDButil->FilterTemperature(temp)>0.1; + } + if (press) { + 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; + return calPad->GetCalROC(sector)->GetValue(row,pad); +} + +AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){ + // + // GetDrift velocity spline fit + // + TObjArray *arr=GetTimeVdriftSplineRun(run); + if (!arr) return 0; + return dynamic_cast(arr->FindObject(name)); +} + +AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){ + // + // create spline fit from the drift time graph in TimeDrift + // + TObjArray *arr=GetTimeVdriftSplineRun(run); + if (!arr) return 0; + TGraph *graph=dynamic_cast(arr->FindObject(graphName)); + if (!graph) return 0; + AliSplineFit *fit = new AliSplineFit(); + fit->SetGraph(graph); + fit->SetMinPoints(graph->GetN()+1); + fit->InitKnots(graph,2,0,0.001); + fit->SplineFit(0); + return fit; +} + +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); + grpRun = dynamic_cast(Instance()->fGRPArray.At(run)); + if (!grpRun) return 0; + } + return grpRun; +} + +TMap * AliTPCcalibDB::GetGRPMap(Int_t run){ + // + // Get GRP map for given run + // + TMap * grpRun = dynamic_cast((Instance()->fGRPMaps).At(run)); + if (!grpRun) { + Instance()->UpdateRunInformations(run); + grpRun = dynamic_cast(Instance()->fGRPMaps.At(run)); + if (!grpRun) return 0; + } + return grpRun; +} + + +AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){ + // + // Get Pressure sensor + // run = run number + // type = 0 - Cavern pressure + // 1 - Suface pressure + // First try to get if trom map - if existing (Old format of data storing) + // + + + TMap *map = GetGRPMap(run); + if (map){ + AliDCSSensor * sensor = 0; + TObject *osensor=0; + if (type==0) osensor = ((*map)("fCavernPressure")); + if (type==1) osensor = ((*map)("fP2Pressure")); + sensor =dynamic_cast(osensor); + if (sensor) return sensor; + } + // + // If not map try to get it from the GRPObject + // + AliGRPObject * grpRun = dynamic_cast(fGRPArray.At(run)); + if (!grpRun) { + UpdateRunInformations(run); + grpRun = dynamic_cast(fGRPArray.At(run)); + if (!grpRun) return 0; + } + AliDCSSensor * sensor = grpRun->GetCavernAtmosPressure(); + if (type==1) sensor = grpRun->GetSurfaceAtmosPressure(); + return sensor; +} + +AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){ + // + // Get temperature sensor array + // + AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run); + if (!tempArray) { + UpdateRunInformations(run); + tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run); + } + return tempArray; +} + + +TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){ + // + // Get temperature sensor array + // + TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run); + if (!gainSplines) { + UpdateRunInformations(run); + gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run); + } + return gainSplines; +} + +TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){ + // + // Get drift spline array + // + TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.At(run); + if (!driftSplines) { + UpdateRunInformations(run); + driftSplines = (TObjArray *)fDriftCorrectionArray.At(run); + } + return driftSplines; +} + +AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){ + // + // Get temperature sensor array + // + AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.At(run); + if (!voltageArray) { + UpdateRunInformations(run); + voltageArray = (AliDCSSensorArray *)fVoltageArray.At(run); + } + return voltageArray; +} + +AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){ + // + // Get temperature sensor array + // + AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run); + if (!goofieArray) { + UpdateRunInformations(run); + goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run); + } + return goofieArray; +} + + + +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); + vdrift= (AliTPCCalibVdrift*)fVdriftArray.At(run); + } + return vdrift; +} + +Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries) +{ + // + // GetCE drift time information for 'sector' + // sector 72 is the mean drift time of the A-Side + // sector 73 is the mean drift time of the C-Side + // it timestamp==-1 return mean value + // + AliTPCcalibDB::Instance()->SetRun(run); + TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector); + if (!gr||sector<0||sector>73) { + if (entries) *entries=0; + return 0.; + } + Float_t val=0.; + if (timeStamp==-1.){ + val=gr->GetMean(2); + }else{ + for (Int_t ipoint=0;ipointGetN();++ipoint){ + Double_t x,y; + gr->GetPoint(ipoint,x,y); + if (xSetRun(run); + TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector); + if (!gr||sector<0||sector>71) { + if (entries) *entries=0; + return 0.; + } + Float_t val=0.; + if (timeStamp==-1.){ + val=gr->GetMean(2); + }else{ + for (Int_t ipoint=0;ipointGetN();++ipoint){ + Double_t x,y; + gr->GetPoint(ipoint,x,y); + if (xGetSensor(sensorNameString); + if (!sensor) return val; + //use the dcs graph if possible + TGraph *gr=sensor->GetGraph(); + if (gr){ + for (Int_t ipoint=0;ipointGetN();++ipoint){ + Double_t x,y; + gr->GetPoint(ipoint,x,y); + Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours + if (timeGetPoint(0,x,y); + Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours + if ((time-timeStamp)<5*60) val=y; + } + //last point + if (val==0 ){ + Double_t x,y; + gr->GetPoint(gr->GetN()-1,x,y); + Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours + if ((timeStamp-time)<5*60) val=y; + } + } else { + val=sensor->GetValue(timeStamp); + } + if (sigDigits>=0){ + val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits) +{ + // + // Get mean Value for a DCS sensor 'sensorName' during run 'run' + // + Float_t val=0; + const TString sensorNameString(sensorName); + AliDCSSensor *sensor = arr->GetSensor(sensorNameString); + if (!sensor) return val; + + //use dcs graph if it exists + TGraph *gr=sensor->GetGraph(); + if (gr){ + val=gr->GetMean(2); + } else { + //if we don't have the dcs graph, try to get some meaningful information + if (!sensor->GetFit()) return val; + Int_t nKnots=sensor->GetFit()->GetKnots(); + Double_t tMid=(sensor->GetEndTime()-sensor->GetStartTime())/2.; + for (Int_t iKnot=0;iKnotGetFit()->GetX()[iKnot]>tMid/3600.) break; + val=(Float_t)sensor->GetFit()->GetY0()[iKnot]; + } + } + if (sigDigits>=0){ + // val/=10; + val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits); + // val*=10; + } + return val; +} + +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 + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + if (sector<36){ + //IROC + sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,sector%18); + }else{ + //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 { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} +Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) +{ + // + // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC + // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side + // if timeStamp==-1 return the mean value for the run + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + sensorName=Form("TPC_SKIRT_%c_VMEAS",sideName); + if (timeStamp==-1){ + val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); + } else { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) +{ + // + // Get the cover voltage for run 'run' at time 'timeStamp' + // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side + // if timeStamp==-1 return the mean value for the run + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + if (sector<36){ + //IROC + sensorName=Form("TPC_COVER_I_%c_VMEAS",sideName); + }else{ + //OROC + sensorName=Form("TPC_COVER_O_%c_VMEAS",sideName); + } + if (timeStamp==-1){ + val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); + } else { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) +{ + // + // Get the GG offset voltage for run 'run' at time 'timeStamp' + // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side + // if timeStamp==-1 return the mean value for the run + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + if (sector<36){ + //IROC + sensorName=Form("TPC_GATE_I_%c_OFF_VMEAS",sideName); + }else{ + //OROC + sensorName=Form("TPC_GATE_O_%c_OFF_VMEAS",sideName); + } + if (timeStamp==-1){ + val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); + } else { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) +{ + // + // Get the GG offset voltage for run 'run' at time 'timeStamp' + // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side + // if timeStamp==-1 return the mean value for the run + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + if (sector<36){ + //IROC + sensorName=Form("TPC_GATE_I_%c_NEG_VMEAS",sideName); + }else{ + //OROC + sensorName=Form("TPC_GATE_O_%c_NEG_VMEAS",sideName); + } + if (timeStamp==-1){ + val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); + } else { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits) +{ + // + // Get the GG offset voltage for run 'run' at time 'timeStamp' + // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side + // if timeStamp==-1 return the mean value for the run + // + Float_t val=0; + TString sensorName=""; + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run); + if (!voltageArray || (sector<0) || (sector>71)) return val; + Char_t sideName='A'; + if ((sector/18)%2==1) sideName='C'; + if (sector<36){ + //IROC + sensorName=Form("TPC_GATE_I_%c_POS_VMEAS",sideName); + }else{ + //OROC + sensorName=Form("TPC_GATE_O_%c_POS_VMEAS",sideName); + } + if (timeStamp==-1){ + val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits); + } else { + val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits); + } + return val; +} + +Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){ + // + // GetPressure for given time stamp and runt + // + TTimeStamp stamp(timeStamp); + AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type); + if (!sensor) return 0; + return sensor->GetValue(stamp); +} + +Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){ + // + // return L3 current + // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4 + // + Float_t current=-1; + AliGRPObject *grp=AliTPCcalibDB::GetGRP(run); + if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType); + return current; +} + +Float_t AliTPCcalibDB::GetBz(Int_t run){ + // + // calculate BZ in T from L3 current + // + Float_t bz=-1; + Float_t current=AliTPCcalibDB::GetL3Current(run); + if (current>-1) bz=5*current/30000.*.1; + return bz; +} + +Char_t AliTPCcalibDB::GetL3Polarity(Int_t run) { + // + // get l3 polarity from GRP + // + Char_t pol=-100; + AliGRPObject *grp=AliTPCcalibDB::GetGRP(run); + if (grp) pol=grp->GetL3Polarity(); + return pol; +} + +TString AliTPCcalibDB::GetRunType(Int_t run){ + // + // return run type from grp + // + +// TString type("UNKNOWN"); + AliGRPObject *grp=AliTPCcalibDB::GetGRP(run); + if (grp) return grp->GetRunType(); + return "UNKNOWN"; +} + +Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){ + // + // GetPressure for given time stamp and runt + // + TTimeStamp stamp(timeStamp); + AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run); + if (!goofieArray) return 0; + AliDCSSensor *sensor = goofieArray->GetSensor(type); + return sensor->GetValue(stamp); +} + + + + + + +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); + if (! tempArray) return kFALSE; + AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray); + TLinearFitter * fitter = tempMap->GetLinearFitter(3,side,tstamp); + if (fitter){ + fitter->Eval(); + fitter->GetParameters(fit); + } + delete fitter; + delete tempMap; + if (!fitter) return kFALSE; + return kTRUE; +} + +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); + return vec[0]; + } + if (side==1){ + GetTemperatureFit(timeStamp,run,0,vec); + return vec[0]; + } + return 0; +} + + +Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){ + // + // Get relative P/T + // time - absolute time + // run - run number + // side - 0 - A side 1-C side + AliTPCCalibVdrift * vdrift = Instance()->GetVdrift(run); + if (!vdrift) return 0; + return vdrift->GetPTRelative(timeSec,side); +} + +AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){ + // + // Function to covert old GRP run information from TMap to GRPObject + // + // TMap * map = AliTPCcalibDB::GetGRPMap(52406); + if (!map) return 0; + AliDCSSensor * sensor = 0; + TObject *osensor=0; + osensor = ((*map)("fP2Pressure")); + sensor =dynamic_cast(osensor); + // + if (!sensor) return 0; + // + AliDCSSensor * sensor2 = new AliDCSSensor(*sensor); + osensor = ((*map)("fCavernPressure")); + TGraph * gr = new TGraph(2); + gr->GetX()[0]= -100000.; + gr->GetX()[1]= 1000000.; + gr->GetY()[0]= atof(osensor->GetName()); + gr->GetY()[1]= atof(osensor->GetName()); + sensor2->SetGraph(gr); + sensor2->SetFit(0); + + + AliGRPObject *grpRun = new AliGRPObject; + grpRun->ReadValuesFromMap(map); + grpRun->SetCavernAtmosPressure(sensor2); + grpRun->SetCavernAtmosPressure(sensor2); + grpRun->SetSurfaceAtmosPressure(sensor); + return grpRun; +} + +Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename) +{ + // + // Create a gui tree for run number 'run' + // + + if (!AliCDBManager::Instance()->GetDefaultStorage()){ + AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!", + MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__); + return kFALSE; + } + //db instance + AliTPCcalibDB *db=AliTPCcalibDB::Instance(); + // retrieve cal pad objects + db->SetRun(run); + db->CreateGUITree(filename); + return kTRUE; +} + +Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){ + // + // + // + if (!AliCDBManager::Instance()->GetDefaultStorage()){ + 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()))); + if (GetPadNoise() ) prep.AddComponent(new AliTPCCalPad(*(GetPadNoise()))); + //pulser data + if (GetPulserTmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserTmean()))); + if (GetPulserTrms() ) prep.AddComponent(new AliTPCCalPad(*(GetPulserTrms()))); + if (GetPulserQmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserQmean()))); + //CE data + if (GetCETmean()) prep.AddComponent(new AliTPCCalPad(*(GetCETmean()))); + if (GetCETrms() ) prep.AddComponent(new AliTPCCalPad(*(GetCETrms()))); + if (GetCEQmean()) prep.AddComponent(new AliTPCCalPad(*(GetCEQmean()))); + //Altro data + if (GetALTROAcqStart() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStart() ))); + if (GetALTROZsThr() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROZsThr() ))); + if (GetALTROFPED() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROFPED() ))); + if (GetALTROAcqStop() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStop() ))); + if (GetALTROMasked() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROMasked() ))); + //QA + AliTPCdataQA *dataQA=GetDataQA(); + if (dataQA) { + if (dataQA->GetNLocalMaxima()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNLocalMaxima()))); + if (dataQA->GetMaxCharge()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMaxCharge()))); + if (dataQA->GetMeanCharge()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMeanCharge()))); + if (dataQA->GetNoThreshold()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNoThreshold()))); + if (dataQA->GetNTimeBins()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNTimeBins()))); + if (dataQA->GetNPads()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNPads()))); + if (dataQA->GetTimePosition()) + prep.AddComponent(new AliTPCCalPad(*(dataQA->GetTimePosition()))); + } + + // + TString file(filename); + if (file.IsNull()) file=Form("guiTreeRun_%lld.root",fRun); + prep.DumpToFile(file.Data()); + return kTRUE; +} + +Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename) +{ + // + // Create a gui tree for run number 'run' + // + + if (!AliCDBManager::Instance()->GetDefaultStorage()){ + AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!", + MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__); + return kFALSE; + } + TString file(filename); + if (file.IsNull()) file=Form("RefCalPads_%d.root",run); + TDirectory *currDir=gDirectory; + //db instance + AliTPCcalibDB *db=AliTPCcalibDB::Instance(); + // retrieve cal pad objects + db->SetRun(run); + //open file + TFile f(file.Data(),"recreate"); + //noise and pedestals + db->GetPedestals()->Write("Pedestals"); + db->GetPadNoise()->Write("PadNoise"); + //pulser data + db->GetPulserTmean()->Write("PulserTmean"); + db->GetPulserTrms()->Write("PulserTrms"); + db->GetPulserQmean()->Write("PulserQmean"); + //CE data + db->GetCETmean()->Write("CETmean"); + db->GetCETrms()->Write("CETrms"); + db->GetCEQmean()->Write("CEQmean"); + //Altro data + db->GetALTROAcqStart() ->Write("ALTROAcqStart"); + db->GetALTROZsThr() ->Write("ALTROZsThr"); + db->GetALTROFPED() ->Write("ALTROFPED"); + db->GetALTROAcqStop() ->Write("ALTROAcqStop"); + db->GetALTROMasked() ->Write("ALTROMasked"); + // + f.Close(); + currDir->cd(); + return kTRUE; +} + + + +Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){ + // + // Get time dependent drift velocity correction + // multiplication factor vd = vdnom *(1+vdriftcorr) + // Arguments: + // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks + // timestamp - timestamp + // run - run number + // side - the drift velocity per side (possible for laser and CE) + // + // Notice - Extrapolation outside of calibration range - using constant function + // + Double_t result=0; + // mode 1 automatic mode - according to the distance to the valid calibration + // - + Double_t deltaP=0, driftP=0, wP = 0.; + Double_t deltaITS=0,driftITS=0, wITS= 0.; + Double_t deltaLT=0, driftLT=0, wLT = 0.; + Double_t deltaCE=0, driftCE=0, wCE = 0.; + driftP = fDButil->GetVDriftTPC(deltaP,run,timeStamp); + driftITS= fDButil->GetVDriftTPCITS(deltaITS,run,timeStamp); + driftCE = fDButil->GetVDriftTPCCE(deltaCE, run,timeStamp,36000,2); + driftLT = fDButil->GetVDriftTPCLaserTracks(deltaLT,run,timeStamp,36000,2); + deltaITS = TMath::Abs(deltaITS); + deltaP = TMath::Abs(deltaP); + deltaLT = TMath::Abs(deltaLT); + deltaCE = TMath::Abs(deltaCE); + 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); + wCE = 1. *kdeltaT/(deltaCE +kdeltaT); + // + // + if (TMath::Abs(driftP)GetTriggerOffsetTPC(run,timeStamp); + result *=fParam->GetZLength(); + } + if (mode==1){ + // TPC-ITS mode + Double_t dist=0; + result= -fDButil->GetTime0TPCITS(dist, run, timeStamp)*fParam->GetDriftV()/1000000.; + } + return result; + +} + + + + +Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){ + // + // Get global y correction drift velocity correction factor + // additive factor vd = vdnom*(1+GetVDriftCorrectionGy *gy) + // Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS + // Arguments: + // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS + // timestamp - timestamp + // run - run number + // side - the drift velocity gy correction per side (CE and Laser tracks) + // + // Notice - Extrapolation outside of calibration range - using constant function + // + if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber(); + UpdateRunInformations(run,kFALSE); + TObjArray *array =AliTPCcalibDB::Instance()->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"); + + if (laserA && laserC){ + result= (laserA->Eval(timeStamp)+laserC->Eval(timeStamp))*0.5; + } + if (laserA && side==0){ + result = (laserA->Eval(timeStamp)); + } + 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); // +} +