+
+//
+// Check if calibration is complete -- otherwise take from old OCDB entry
+
+// inner sectors
+ for (Int_t sector=0; sector<nSectors/2; sector++) {
+ if (foundSectorsPed[sector] < 1 ) {
+ if (calPadPedOCDB) {
+ AliTPCCalROC *rocOCDB=calPadPedOCDB->GetCalROC(sector);
+ calPadPed->SetCalROC(rocOCDB,sector);
+ } else {
+ const int mess_length=100;
+ char message[mess_length];
+ snprintf(message,mess_length,"Missing pedestals for sector %d - also not available from previous OCDB entry.\n",
+ sector);
+ Log (message);
+ result = 2;
+ }
+ }
+ if (foundSectorsRMS[sector] < 1 ) {
+ if (calPadRMSOCDB) {
+ AliTPCCalROC *rocOCDB=calPadRMSOCDB->GetCalROC(sector);
+ calPadRMS->SetCalROC(rocOCDB,sector);
+ } else {
+ const int mess_length=100;
+ char message[mess_length];
+ snprintf(message,mess_length,"Missing pedestal RMS for sector %d - also not available from previous OCDB entry.\n",
+ sector);
+ Log (message);
+ result = 2;
+ }
+ }
+ }
+
+// outer sectors -- two updates needed
+
+ for (Int_t sector=nSectors/2; sector<nSectors; sector++) {
+ if (foundSectorsPed[sector] < 2 ) {
+ if (calPadPedOCDB) {
+ AliTPCCalROC *rocOCDB=calPadPedOCDB->GetCalROC(sector);
+ calPadPed->SetCalROC(rocOCDB,sector);
+ } else {
+ const int mess_length=100;
+ char message[mess_length];
+ snprintf(message,mess_length,"Missing pedestals for sector %d - also not available from previous OCDB entry.\n",
+ sector);
+ Log (message);
+ result = 2;
+ }
+
+ }
+ if (foundSectorsRMS[sector] < 2 ) {
+ if (calPadRMSOCDB) {
+ AliTPCCalROC *rocOCDB=calPadRMSOCDB->GetCalROC(sector);
+ calPadRMS->SetCalROC(rocOCDB,sector);
+ } else {
+ const int mess_length=100;
+ char message[mess_length];
+ snprintf(message,mess_length,"Missing pedestal RMS for sector %d - also not available from previous OCDB entry.\n",
+ sector);
+ Log (message);
+ result = 2;
+ }
+
+ }
+ }
+
+
+//
+// Store updated pedestal entry to OCDB
+//
+ if (changed) {
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Haavard Helstrup");
+ metaData.SetAliRootVersion(ALIROOT_SVN_BRANCH);
+ metaData.SetComment("Preprocessor AliTPC data base entries.");
+
+ Bool_t storeOK = Store("Calib", "Pedestals", calPadPed, &metaData, 0, kTRUE);
+ if ( !storeOK ) ++result;
+ storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
+ if ( !storeOK ) ++result;
+ }
+ } else {
+ Log ("Error: no entries in pedestal file list!");
+ result = 1;
+ }
+
+ delete calPadPed;
+ delete calPadRMS;
+ delete calPadPedOCDB;
+ delete calPadRMSOCDB;
+
+ return result;
+}
+
+//______________________________________________________________________________________________
+
+
+UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
+{
+ //
+ // Read pulser calibration file from file exchage server
+ // Keep original entry from OCDB in case no new pulser calibration is available
+ //
+
+ TObjArray *pulserObjects = new TObjArray;
+ TObjArray *pulserObjectsOCDB=0;
+
+ AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
+ if (entry) pulserObjectsOCDB = (TObjArray*)entry->GetObject();
+ if ( pulserObjectsOCDB==NULL ) {
+ Log("AliTPCPreprocsessor: No previous TPC pulser entry available.\n");
+ }
+
+ AliTPCCalPad *pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
+ pulserObjects->Add(pulserTmean);
+
+ AliTPCCalPad *pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
+ pulserObjects->Add(pulserTrms);
+
+ AliTPCCalPad *pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
+ pulserObjects->Add(pulserQmean);
+
+
+
+ UInt_t result=0;
+
+ Int_t nSectors = fROC->GetNSectors();
+ TVectorD foundTmean(nSectors);
+ foundTmean=0;
+ TVectorD foundTrms(nSectors);
+ foundTrms=0;
+ TVectorD foundQmean(nSectors);
+ foundQmean=0;
+
+
+ TList* list = GetFileSources(sourceFXS,"pulser");
+
+ if (list && list->GetEntries()>0) {
+
+// loop through all files from LDCs
+
+ Bool_t changed=false;
+ UInt_t index = 0;
+ while (list->At(index)!=NULL) {
+ TObjString* fileNameEntry = (TObjString*) list->At(index);
+ if (fileNameEntry!=NULL) {
+ TString fileName = GetFile(sourceFXS, "pulser",
+ fileNameEntry->GetString().Data());
+ TFile *f = TFile::Open(fileName);
+ if (!f) {
+ Log ("Error opening pulser file.");
+ result =2;
+ break;
+ }
+ AliTPCCalibPulser *calPulser;
+ f->GetObject("tpcCalibPulser",calPulser);
+ if ( !calPulser ) {
+ Log ("No pulser calibration object in file.");
+ result = 2;
+ break;
+ }
+
+ // replace entries for the sectors available in the present file
+
+ changed=true;
+ for (Int_t sector=0; sector<nSectors; sector++) {
+ AliTPCCalROC *rocTmean=calPulser->GetCalRocT0(sector);
+ if ( rocTmean ) {
+ AliTPCCalROC* roc=pulserTmean->GetCalROC(sector);
+ roc->Add(rocTmean,1);
+ foundTmean[sector]++;
+ }
+ AliTPCCalROC *rocTrms=calPulser->GetCalRocRMS(sector);
+ if ( rocTrms ) {
+ AliTPCCalROC* roc=pulserTrms->GetCalROC(sector);
+ roc->Add(rocTrms,1);
+ foundTrms[sector]++;
+ }
+ AliTPCCalROC *rocQmean=calPulser->GetCalRocQ(sector);
+ if ( rocQmean ) {
+ AliTPCCalROC* roc=pulserQmean->GetCalROC(sector);
+ roc->Add(rocQmean,1);
+ foundQmean[sector]++;
+ }
+ }
+ delete calPulser;
+ f->Close();
+ }
+ ++index;
+ } // while(list)
+
+
+
+
+if (pulserObjectsOCDB) {
+ AliTPCCalPad* pulserTmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTmean");
+ AliTPCCalPad* pulserTrmsOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTrms");
+ AliTPCCalPad* pulserQmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserQmean");
+
+//
+// Check if calibration is complete -- otherwise take from old OCDB entry
+
+// inner sectors
+ for (Int_t sector=0; sector<nSectors/2; sector++) {
+ if (foundTmean[sector] < 1 ) {
+ if (pulserTmeanOCDB) {
+ AliTPCCalROC* rocOCDB = pulserTmeanOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserTmean->SetCalROC(rocOCDB,sector);
+ }
+ }
+ if (foundTrms[sector] < 1 ) {
+ if (pulserTrmsOCDB) {
+ AliTPCCalROC* rocOCDB = pulserTrmsOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserTrms->SetCalROC(rocOCDB,sector);
+ }
+ }
+ if (foundQmean[sector] < 1 ) {
+ if (pulserQmeanOCDB) {
+ AliTPCCalROC* rocOCDB = pulserQmeanOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserQmean->SetCalROC(rocOCDB,sector);
+ }
+ }
+ }
+
+// outer sectors -- two updates needed
+
+ for (Int_t sector=0; sector<nSectors/2; sector++) {
+ if (foundTmean[sector] < 2 ) {
+ if (pulserTmeanOCDB) {
+ AliTPCCalROC* rocOCDB = pulserTmeanOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserTmean->SetCalROC(rocOCDB,sector);
+ }
+ }
+ if (foundTrms[sector] < 2 ) {
+ if (pulserTrmsOCDB) {
+ AliTPCCalROC* rocOCDB = pulserTrmsOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserTrms->SetCalROC(rocOCDB,sector);
+ }
+ }
+ if (foundQmean[sector] < 2 ) {
+ if (pulserQmeanOCDB) {
+ AliTPCCalROC* rocOCDB = pulserQmeanOCDB->GetCalROC(sector);
+ if ( rocOCDB ) pulserQmean->SetCalROC(rocOCDB,sector);
+ }
+ }
+
+ }
+}
+
+//
+// Store updated pedestal entry to OCDB
+//
+ if (changed) {
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Haavard Helstrup");
+ metaData.SetAliRootVersion(ALIROOT_SVN_BRANCH);
+ metaData.SetComment("Preprocessor AliTPC data base entries.");
+
+ Bool_t storeOK = Store("Calib", "Pulser", pulserObjects, &metaData, 0, kTRUE);
+ if ( !storeOK ) ++result;
+ }
+ } else {
+ Log ("Error: no entries in pulser file list!");
+ result = 1;
+ }
+ pulserObjects->Delete();
+ delete pulserObjects;
+ if (pulserObjectsOCDB) pulserObjectsOCDB->Delete();
+ delete pulserObjectsOCDB;
+
+ return result;
+}
+
+//______________________________________________________________________________________________
+
+
+UInt_t AliTPCPreprocessor::ExtractRaw(Int_t sourceFXS)
+{
+ //
+ // Read Raw calibration file from file exchage server
+ //
+
+ UInt_t result=0;
+ TObjArray* rawArray = new TObjArray;
+
+ TList* list = GetFileSources(sourceFXS,"tpcCalibRaw");
+
+ if (list && list->GetEntries()>0) {
+
+// loop through all files
+
+ UInt_t index = 0;
+ while (list->At(index)!=NULL) {
+ TObjString* fileNameEntry = (TObjString*) list->At(index);
+ if (fileNameEntry!=NULL) {
+ TString fileName = GetFile(sourceFXS, "tpcCalibRaw",
+ fileNameEntry->GetString().Data());
+ TFile *f = TFile::Open(fileName);
+ if (!f) {
+ Log ("Error opening raw file.");
+ result =2;
+ break;
+ }
+ AliTPCCalibRaw *calRaw;
+ f->GetObject("tpcCalibRaw",calRaw);
+ if ( !calRaw ) {
+ Log ("No raw calibration object in file.");
+ result = 2;
+ break;
+ }
+ rawArray->Add(calRaw);
+ f->Close();
+ }
+ ++index;
+ } // while(list)
+//
+// Store updated pedestal entry to OCDB
+//
+ AliCDBMetaData metaData;
+ metaData.SetBeamPeriod(0);
+ metaData.SetResponsible("Haavard Helstrup");
+ metaData.SetAliRootVersion(ALIROOT_SVN_BRANCH);
+ metaData.SetComment("Preprocessor AliTPC data base entries.");
+
+ Bool_t storeOK = Store("Calib", "Raw", rawArray, &metaData, 0, kTRUE);
+ if ( !storeOK ) ++result;
+ } else {
+ Log ("Error: no entries in raw file list!");
+ result = 1;
+ }
+
+ rawArray->Delete();
+ delete rawArray;
+
+ return result;
+}
+//______________________________________________________________________________________________
+
+UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
+{
+ //
+ // Read Central Electrode file from file exchage server
+ //
+ //
+ AliTPCCalPad *ceTmean=0;
+ AliTPCCalPad *ceTrms=0;
+ AliTPCCalPad *ceQmean=0;
+ TObjArray *rocTtime=0;
+ TObjArray *rocQtime=0;
+
+ TObjArray *ceObjects= new TObjArray;
+
+
+ Int_t nSectors = fROC->GetNSectors();
+
+ ceTmean = new AliTPCCalPad("CETmean","CETmean");
+ ceObjects->Add(ceTmean);
+
+ ceTrms = new AliTPCCalPad("CETrms","CETrms");
+ ceObjects->Add(ceTrms);
+
+ ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
+ ceObjects->Add(ceQmean);
+
+ rocTtime = new TObjArray(nSectors+2); // also make room for A and C side average
+ rocTtime->SetName("rocTtime");
+ ceObjects->Add(rocTtime);
+
+ rocQtime = new TObjArray(nSectors);
+ rocQtime->SetName("rocQtime");
+ ceObjects->Add(rocQtime);
+
+ //=== new part
+ TObjArray *arrFitGraphs=new TObjArray;
+ arrFitGraphs->SetName("ceFitsDrift");
+ ceObjects->Add(arrFitGraphs);
+
+// Temperature maps
+
+ if (fTemp) {
+ AliTPCSensorTempArray *tempMap = new AliTPCSensorTempArray(*fTemp);
+ tempMap->SetNameTitle("TempMap","TempMap");
+ ceObjects->Add(tempMap);
+ }
+
+// Pressure maps
+
+ if (fPressure) {
+ AliDCSSensor *sensor=0, *sensorCopy=0;
+ for (Int_t isensor=0; isensor<kNumPressureSensors; ++isensor ) {
+ sensor = fPressure->GetSensor(kPressureSensorNames[isensor]);
+ if (sensor) {
+ sensorCopy = new AliDCSSensor(*sensor);
+ sensorCopy->SetNameTitle(kPressureSensorNames[isensor],kPressureSensorNames[isensor]);
+ ceObjects->Add(sensorCopy);
+ }
+ }
+ }
+
+ UInt_t result=0;
+
+ TList* list = GetFileSources(sourceFXS,"CE");
+
+ if (list && list->GetEntries()>0) {
+
+// loop through all files from LDCs
+
+ UInt_t index = 0;
+ while (list->At(index)!=NULL) {
+ TObjString* fileNameEntry = (TObjString*) list->At(index);
+ if (fileNameEntry!=NULL) {
+ TString fileName = GetFile(sourceFXS, "CE",
+ fileNameEntry->GetString().Data());
+ AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
+ if (!calCE) {
+ Log ("No valid calibCE object.");
+ result=2;
+ break;
+ }
+ // replace entries for the sectors available in the present file
+
+ for (Int_t sector=0; sector<nSectors; sector++) {
+ AliTPCCalROC *rocTmean=calCE->GetCalRocT0(sector);
+ if ( rocTmean ) ceTmean->SetCalROC(rocTmean,sector);
+ AliTPCCalROC *rocTrms=calCE->GetCalRocRMS(sector);
+ if ( rocTrms ) ceTrms->SetCalROC(rocTrms,sector);
+ AliTPCCalROC *rocQmean=calCE->GetCalRocQ(sector);
+ if ( rocQmean ) ceQmean->SetCalROC(rocQmean,sector);
+ TGraph *grT=calCE->MakeGraphTimeCE(sector,0,2); // T time graph
+ if ( grT ) rocTtime->AddAt(grT,sector);
+ TGraph *grQ=calCE->MakeGraphTimeCE(sector,0,3); // Q time graph
+ if ( grQ ) rocQtime->AddAt(grQ,sector);
+ }
+
+ TGraph *grT=calCE->MakeGraphTimeCE(-1,0,2); // A side average
+ if ( grT ) {
+ rocTtime->AddAt(grT,nSectors);
+ } else {
+ result=10;
+ }
+ grT=calCE->MakeGraphTimeCE(-2,0,2); // C side average
+ if ( grT ) {
+ rocTtime->AddAt(grT,nSectors+1);
+ } else {
+ result=10;
+ }
+
+ delete calCE;
+ }
+ ++index;
+ } // while(list)
+//
+// Check number of calibrated sectors per side
+//
+ Int_t aside=0, cside=0;
+ for (Int_t ind=0; ind<nSectors/4; ind++ ) {
+ TGraph *grT=(TGraph*)rocTtime->At(ind);
+ if (grT) aside++;
+ grT=(TGraph*)rocTtime->At(ind+nSectors/2);
+ if (grT) aside++;
+ grT=(TGraph*)rocTtime->At(ind+nSectors/4);
+ if (grT) cside++;
+ grT=(TGraph*)rocTtime->At(ind+3*nSectors/4);
+ if (grT) cside++;
+ }
+ if ( (aside<kMinCESectors) && (cside<kMinCESectors) ) {
+ Log (Form("ExtractCE: Too few fitted sectors: Aside =%d, Cside=%d\n",
+ aside, cside)) ;
+ result=10;
+ }
+
+ //
+ //=== New CE part
+ // if it is validated this part needs to be modified again
+ // currently its only processed if there is a valid standard CE object
+ //
+ list = GetFileSources(sourceFXS,"CEnew");
+
+ if (result==0 && list && list->GetEntries()>0) {
+
+// loop through all files from LDCs
+
+ UInt_t index2 = 0;
+ while (list->At(index2)!=NULL) {
+ TObjString* fileNameEntry = (TObjString*) list->At(index2);
+ if (fileNameEntry!=NULL) {
+ TString fileName = GetFile(sourceFXS, "CEnew",
+ fileNameEntry->GetString().Data());
+ AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
+ if (!calCE) {
+ Log ("No valid new calibCE object.");
+// result=2;
+ break;
+ }
+
+ TIter nextObj(calCE->GetArrFitGraphs());
+ TObject *obj=0x0;
+ while ( (obj=nextObj()) ){
+ arrFitGraphs->Add(obj->Clone());
+ }
+ delete calCE;
+ }
+ ++index2;
+ }
+ }
+