X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCcalibDB.cxx;h=b2c520ba3cc394793efcc14dfd51cfb38980fb9b;hb=40a0a69c6f8c4bc355d0217882c78f0f9b02c02b;hp=15cb9a447a92b1d8de1e645f94cb1e56ba96c8b0;hpb=bfec3eeb7dcd331c145657261268ac035ca16806;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCcalibDB.cxx b/TPC/AliTPCcalibDB.cxx index 15cb9a447a9..b2c520ba3cc 100644 --- a/TPC/AliTPCcalibDB.cxx +++ b/TPC/AliTPCcalibDB.cxx @@ -82,10 +82,15 @@ #include #include +#include #include #include +#include +#include #include "AliTPCcalibDB.h" +#include "AliTPCdataQA.h" +#include "AliTPCcalibDButil.h" #include "AliTPCAltroMapping.h" #include "AliTPCExB.h" @@ -94,6 +99,7 @@ #include "AliTPCSensorTempArray.h" #include "AliGRPObject.h" #include "AliTPCTransform.h" +#include "AliTPCmapper.h" class AliCDBStorage; class AliTPCCalDet; @@ -102,10 +108,13 @@ 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" @@ -113,8 +122,11 @@ class AliTPCCalDet; #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) @@ -167,25 +179,40 @@ AliTPCcalibDB::AliTPCcalibDB(): 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 - fRunList(100000) //! run list - indicates try to get the run param - + 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 } @@ -197,19 +224,34 @@ AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ): 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 - fRunList(0) //! run list - indicates try to get the run param + 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 @@ -235,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) @@ -253,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; } @@ -269,31 +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"); @@ -301,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"); @@ -309,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"); @@ -330,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; @@ -347,23 +449,45 @@ 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(); // - // ExB - calculate during initialization - // - - fExB = GetExB(-5,kTRUE); - // if (!fTransform) { fTransform=new AliTPCTransform(); fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun()); @@ -371,7 +495,35 @@ void AliTPCcalibDB::Update(){ // 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); + } + } + } @@ -678,7 +830,42 @@ 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){ // @@ -686,9 +873,11 @@ void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){ // 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 + 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", 2,factor,1., 10.,AliMagF::k5kG,"$(ALICE_ROOT)/data/maps/mfchebKGI_sym.root"); + 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); @@ -723,14 +912,27 @@ void AliTPCcalibDB::SetExBField(Float_t bz){ 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::GetRunInformations( Int_t run){ + + + +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.GetSize()){ + if (run>= fRunList.fN){ fRunList.Set(run*2+1); fGRPArray.Expand(run*2+1); fGRPMaps.Expand(run*2+1); @@ -738,8 +940,21 @@ void AliTPCcalibDB::GetRunInformations( Int_t run){ 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) return; + 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()); @@ -756,40 +971,112 @@ void AliTPCcalibDB::GetRunInformations( Int_t run){ fGRPArray.AddAt(grpRun,run); } entry = AliCDBManager::Instance()->Get("TPC/Calib/Goofie",run); - if (entry) fGoofieArray.AddAt(entry->GetObject(),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/HighVoltage",run); - if (entry) fVoltageArray.AddAt(entry->GetObject(),run); + 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); - fRunList[run]=1; // sign as used + 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); - if (press && temp){ + 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()->GetRunInformations(run); + Instance()->UpdateRunInformations(run); grpRun = dynamic_cast(Instance()->fGRPArray.At(run)); if (!grpRun) return 0; } @@ -798,11 +1085,11 @@ 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) { - Instance()->GetRunInformations(run); + Instance()->UpdateRunInformations(run); grpRun = dynamic_cast(Instance()->fGRPMaps.At(run)); if (!grpRun) return 0; } @@ -834,7 +1121,7 @@ AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){ // AliGRPObject * grpRun = dynamic_cast(fGRPArray.At(run)); if (!grpRun) { - GetRunInformations(run); + UpdateRunInformations(run); grpRun = dynamic_cast(fGRPArray.At(run)); if (!grpRun) return 0; } @@ -849,22 +1136,35 @@ AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){ // AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run); if (!tempArray) { - GetRunInformations(run); + UpdateRunInformations(run); tempArray = (AliTPCSensorTempArray *)fTemperatureArray.At(run); } return tempArray; } -AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){ + +TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){ // // Get temperature sensor array // - AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run); - if (!goofieArray) { - GetRunInformations(run); - goofieArray = (AliDCSSensorArray *)fGoofieArray.At(run); + TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run); + if (!gainSplines) { + UpdateRunInformations(run); + gainSplines = (TObjArray *)fTimeGainSplinesArray.At(run); } - return goofieArray; + 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){ @@ -873,35 +1173,347 @@ AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){ // AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.At(run); if (!voltageArray) { - GetRunInformations(run); + 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) { - GetRunInformations(run); + 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) return 0; - AliDCSSensor *sensor = voltageArray->GetSensor((sector+1)*3); - if (!sensor) return 0; - return sensor->GetValue(stamp); + 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){ @@ -914,6 +1526,48 @@ Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){ 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 @@ -932,7 +1586,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); @@ -951,8 +1605,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); @@ -977,149 +1631,6 @@ Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){ return vdrift->GetPTRelative(timeSec,side); } - -void AliTPCcalibDB::ProcessEnv(const char * runList){ - // - // Example test function - how to use the environment variables - // runList - ascii file with run numbers - // output - dcsTime.root file with tree - - ifstream in; - in.open(runList); - Int_t irun=0; - TTreeSRedirector *pcstream = new TTreeSRedirector("dcsTime.root"); - while(in.good()) { - in >> irun; - if (irun==0) continue; - printf("Processing run %d\n",irun); - AliDCSSensor * sensorPressure = AliTPCcalibDB::Instance()->GetPressureSensor(irun); - if (!sensorPressure) continue; - AliTPCSensorTempArray * tempArray = AliTPCcalibDB::Instance()->GetTemperatureSensor(irun); - AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray); - AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(irun); - // - Int_t startTime = sensorPressure->GetStartTime(); - Int_t endTime = sensorPressure->GetEndTime(); - Int_t dtime = TMath::Max((endTime-startTime)/20,10*60); - for (Int_t itime=startTime; itimeGetValue(tstamp); - - TLinearFitter * fitter = 0; - TVectorD vecTemp[10]; - if (itimeGetStartTime().GetSec() || itime>tempArray->GetEndTime().GetSec()){ - }else{ - for (Int_t itype=0; itype<5; itype++) - for (Int_t iside=0; iside<2; iside++){ - fitter= tempMap->GetLinearFitter(itype,iside,tstamp); - if (!fitter) continue; - fitter->Eval(); fitter->GetParameters(vecTemp[itype+iside*5]); - delete fitter; - } - } - - TVectorD vecGoofie, vecEntries, vecMean, vecMedian,vecRMS; - if (goofieArray){ - vecGoofie.ResizeTo(goofieArray->NumSensors()); - ProcessGoofie(goofieArray, vecEntries ,vecMedian, vecMean, vecRMS); - // - for (Int_t isensor=0; isensorNumSensors();isensor++){ - AliDCSSensor *gsensor = goofieArray->GetSensor(isensor); - if (gsensor){ - vecGoofie[isensor] = gsensor->GetValue(tstamp); - } - } - } - - - //tempMap->GetLinearFitter(0,0,itime); - (*pcstream)<<"dcs"<< - "run="<NumSensors(); - vecEntries.ResizeTo(nsensors); - vecMedian.ResizeTo(nsensors); - vecMean.ResizeTo(nsensors); - vecRMS.ResizeTo(nsensors); - TVectorF values; - for (Int_t isensor=0; isensorNumSensors();isensor++){ - AliDCSSensor *gsensor = goofieArray->GetSensor(isensor); - if (gsensor && gsensor->GetGraph()){ - Int_t npoints = gsensor->GetGraph()->GetN(); - // filter zeroes - values.ResizeTo(npoints); - Int_t nused =0; - for (Int_t ipoint=0; ipointGetGraph()->GetY()[ipoint])>kEpsilon && - TMath::Abs(gsensor->GetGraph()->GetY()[ipoint])GetGraph()->GetY()[ipoint]; - nused++; - } - } - // - vecEntries[isensor]= nused; - if (nused>1){ - vecMedian[isensor] = TMath::Median(nused,values.GetMatrixArray()); - vecMean[isensor] = TMath::Mean(nused,values.GetMatrixArray()); - vecRMS[isensor] = TMath::RMS(nused,values.GetMatrixArray()); - } - } - } -} - - - AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){ // // Function to covert old GRP run information from TMap to GRPObject @@ -1147,9 +1658,379 @@ AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){ 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); // +}