AliDCSGenDB/AliTPCGenDBConf/AliTPCGenDBTemp: Hard coded reference to specific storage...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 5 Oct 2007 10:06:01 +0000 (10:06 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 5 Oct 2007 10:06:01 +0000 (10:06 +0000)
STEER/AliDCSGenDB.cxx
STEER/AliDCSGenDB.h
TPC/AliTPCGenDBConf.cxx
TPC/AliTPCGenDBConf.h
TPC/AliTPCGenDBTemp.cxx
TPC/AliTPCGenDBTemp.h
TPC/AliTPCPreprocessor.cxx
TPC/AliTPCPreprocessor.h

index 13ba76b..16d9fd7 100644 (file)
@@ -29,6 +29,8 @@
 // TTimeStamp endTime(2006,10,19,0,0,0,0,kFALSE)
 // Int_t run=2546
 // AliDCSGenDB db
+// db->SetDefaultStorage("local:///afs/cern.ch/alice/tpctest/AliRoot/HEAD");
+// db->SetSpecificStorage("local:///afs/cern.ch/alice/tpctest/Calib/");
 // db->Init(run,"TPC/Config/Pressure","TPC/*/*")
 // db->MakeCalib("PressureSensor.txt","DCSMap.root",startTime,endTime,firstRun,lastRun,"TPC/Calib/Pressure")
 
@@ -36,9 +38,6 @@
 #include "AliDCSGenDB.h"
 #include "AliLog.h"
 
-const char *kDefaultStorage="local:///afs/cern.ch/alice/tpctest/AliRoot/HEAD";
-const char *kSpecificStorage="local:///afs/cern.ch/alice/tpctest/Calib/";
-const char *kSensorClass = "AliDCSSensorArray";
 const Int_t kBeamPeriod=2;
 
 ClassImp(AliDCSGenDB)
@@ -48,8 +47,8 @@ ClassImp(AliDCSGenDB)
 AliDCSGenDB::AliDCSGenDB():
    fFirstRun(0),
    fLastRun(0),
-   fSpecificStorage(kSpecificStorage),
-   fDefaultStorage(kDefaultStorage),
+   fSpecificStorage(0),
+   fDefaultStorage(0),
    fSensor(0),
    fStorLoc(0),
    fMetaData(0),
@@ -61,6 +60,22 @@ AliDCSGenDB::AliDCSGenDB():
 
 //______________________________________________________________________________________________
 
+AliDCSGenDB::AliDCSGenDB(const char* defaultStorage, const char* specificStorage):
+   fFirstRun(0),
+   fLastRun(0),
+   fSpecificStorage(specificStorage),
+   fDefaultStorage(defaultStorage),
+   fSensor(0),
+   fStorLoc(0),
+   fMetaData(0),
+   fConfTree(0)
+//
+//  special constructor
+//
+{}
+
+//______________________________________________________________________________________________
+
 AliDCSGenDB::AliDCSGenDB(const AliDCSGenDB& org):
   TObject(org),
   fFirstRun(org.fFirstRun),
@@ -98,6 +113,7 @@ AliDCSGenDB& AliDCSGenDB::operator= (const AliDCSGenDB& org )
  //
  AliError("assignment operator not implemented");
  return *this;
+
 }
 
 //______________________________________________________________________________________________
@@ -107,10 +123,10 @@ void AliDCSGenDB::MakeCalib(const char *list, const char *mapDCS,
                             const TTimeStamp& endTime,
                             Int_t firstRun, Int_t lastRun, const char *calibDir )
 {
-   // The Terminate() function is the last function to be called during
-   // a query. It always runs on the client, it can be used to present
-   // the results graphically or save the results to file.
 
+   // Generate calibration entry from DCS map
+   // Configuration read from ASCII file specified by list
+   
    TClonesArray *arr = ReadList(list);
    AliDCSSensorArray *fSensor = new AliDCSSensorArray(arr);
    fSensor->SetStartTime(startTime);
@@ -168,10 +184,12 @@ void AliDCSGenDB::StoreObject(const char* cdbPath, TObject* object, AliCDBMetaDa
 }
 
 //______________________________________________________________________________________________
-void AliDCSGenDB::Init(Int_t run, const char *configDir, const char *specificDir)
+void AliDCSGenDB::Init(Int_t run, const char *configDir, 
+                                  const char *specificDir,
+                                 const char *sensorClass)
 {
 
-   fMetaData = CreateMetaObject(kSensorClass);
+   fMetaData = CreateMetaObject(sensorClass);
    AliCDBManager *man = AliCDBManager::Instance();
    man->SetDefaultStorage(fDefaultStorage);
    man->SetRun(run);
index e8c4601..955f86f 100644 (file)
@@ -1,3 +1,4 @@
+
 /////////////////////////////////////////////////////////////////
 // Class to generate temperature sensor data base entries.
 //
@@ -31,6 +32,7 @@ public:
 // Constructors
 
   AliDCSGenDB();
+  AliDCSGenDB(const char* defaultStorage, const char* specificStorage);
   ~AliDCSGenDB();
 
 // Functionality
@@ -39,10 +41,13 @@ public:
                             const TTimeStamp& startTime,
                            const TTimeStamp& endTime,
                            Int_t firstRun, Int_t lastRun, const char *calibDir);
-  void            MakeConfig(const char *file, Int_t firstRun, Int_t lastRun, const char *confDir);
+  void            MakeConfig(const char *file, Int_t firstRun, Int_t lastRun, 
+                             const char *confDir);
   AliCDBMetaData* CreateMetaObject(const char *objectClassName);
   void            StoreObject(const char* cdbPath, TObject* object, AliCDBMetaData* metaData);
-  void            Init(Int_t run, const char *configDir, const char *specificDir);
+  void            Init(Int_t run, const char *configDir, 
+                       const char *specificDir, 
+                      const char *sensorClass="AliDCSSensorArray");
   static TClonesArray *  ReadList(const char* fname, const char *title="dcsConf");
   static TTree        *  ReadListTree(const char* fname, const char *title="dcsConf");
 
index 7fe0865..1cd412e 100644 (file)
@@ -9,6 +9,7 @@
 
 
 #include "AliTPCGenDBConf.h"
+#include "AliLog.h"
 
 ClassImp(AliTPCGenDBConf)
 
@@ -22,15 +23,20 @@ AliTPCGenDBConf::AliTPCGenDBConf():
 
 //______________________________________________________________________________________________
 
-AliTPCGenDBConf::AliTPCGenDBConf(const AliTPCGenDBConf& org):
-  AliDCSGenDB(org)
+AliTPCGenDBConf::AliTPCGenDBConf(const char *defaultStorage, const char *specificStorage):
+   AliDCSGenDB(defaultStorage, specificStorage)
+{
+}
+
+//______________________________________________________________________________________________
+
+AliTPCGenDBConf::AliTPCGenDBConf(const AliTPCGenDBConf& org) : AliDCSGenDB(org)
 {
 
 //
 //  Copy constructor
 //
-
- ((AliTPCGenDBConf &) org).Copy(*this);
+ AliError("copy constructor not implemented");
 }
 
 //______________________________________________________________________________________________
@@ -46,9 +52,7 @@ AliTPCGenDBConf& AliTPCGenDBConf::operator= (const AliTPCGenDBConf& org )
  //
  // assignment operator
  //
- if (&org == this) return *this;
-
- new (this) AliTPCGenDBConf(org);
+ AliError("assignment operator not implemented");
  return *this;
 }
 
index 666d6c8..0aa95bf 100644 (file)
@@ -25,9 +25,8 @@ public:
 // constructors
 
   AliTPCGenDBConf();
-  AliTPCGenDBConf(const AliTPCGenDBConf& org);
+  AliTPCGenDBConf(const char *defaultStorage, const char *specificStorage);
   ~AliTPCGenDBConf();
-  AliTPCGenDBConf& operator= (const AliTPCGenDBConf& org);
 
 // functionality
 
@@ -37,6 +36,8 @@ public:
 
 
 private:
+  AliTPCGenDBConf(const AliTPCGenDBConf& org);
+  AliTPCGenDBConf& operator= (const AliTPCGenDBConf& org);
 
    ClassDef(AliTPCGenDBConf,1)
 };
index c58f498..f4c153e 100644 (file)
@@ -9,6 +9,7 @@
 
 
 #include "AliTPCGenDBTemp.h"
+#include "AliLog.h"
 
 ClassImp(AliTPCGenDBTemp)
 
@@ -24,15 +25,21 @@ AliTPCGenDBTemp::AliTPCGenDBTemp():
 
 //______________________________________________________________________________________________
 
-AliTPCGenDBTemp::AliTPCGenDBTemp(const AliTPCGenDBTemp& org):
-  AliDCSGenDB(org)
+AliTPCGenDBTemp::AliTPCGenDBTemp(const char *defaultStorage, const char *specificStorage) :
+   AliDCSGenDB(defaultStorage,specificStorage)
+{
+}
+
+//______________________________________________________________________________________________
+
+AliTPCGenDBTemp::AliTPCGenDBTemp(const AliTPCGenDBTemp& org) : AliDCSGenDB(org)
 {
 
 //
 //  Copy constructor
 //
+ AliError("copy constructor not implemented");
 
- ((AliTPCGenDBTemp &) org).Copy(*this);
 }
 
 //______________________________________________________________________________________________
@@ -48,9 +55,7 @@ AliTPCGenDBTemp& AliTPCGenDBTemp::operator= (const AliTPCGenDBTemp& org )
  //
  // assignment operator
  //
- if (&org == this) return *this;
-
- new (this) AliTPCGenDBTemp(org);
+ AliError("assignment operator not implemented");
  return *this;
 }
 
index b41c4be..26e6ab8 100644 (file)
@@ -24,9 +24,8 @@ public:
 // constructors
 
   AliTPCGenDBTemp();
-  AliTPCGenDBTemp(const AliTPCGenDBTemp& org);
+  AliTPCGenDBTemp(const char *defaultStorage, const char *specificStorage);
   ~AliTPCGenDBTemp();
-  AliTPCGenDBTemp& operator= (const AliTPCGenDBTemp& org);
   void            MakeCalib(const char *file, const char *fMap,
                             const TTimeStamp& startTime,
                            const TTimeStamp& endTime, Int_t run);
@@ -40,6 +39,8 @@ public:
 
 
 private:
+  AliTPCGenDBTemp(const AliTPCGenDBTemp& org);
+  AliTPCGenDBTemp& operator= (const AliTPCGenDBTemp& org);
 
    ClassDef(AliTPCGenDBTemp,1)
 };
index 9204d4f..acb9473 100644 (file)
@@ -25,6 +25,8 @@
 #include "AliTPCCalROC.h"
 #include "AliTPCCalPad.h"
 #include "AliTPCCalibPedestal.h"
+#include "AliTPCCalibPulser.h"
+#include "AliTPCCalibCE.h"
 #include "TFile.h"
 #include "TTree.h"
 #include "TEnv.h"
@@ -34,6 +36,7 @@
 const Int_t kValCutTemp = 100;               // discard temperatures > 100 degrees
 const Int_t kDiffCutTemp = 5;               // discard temperature differences > 5 degrees
 const TString kPedestalRunType = "PEDESTAL_RUN";  // pedestal run identifier
+const TString kPulserRunType = "PULSER_RUN";   // pulser run identifier
 
 //
 // This class is the SHUTTLE preprocessor for the TPC detector.
@@ -163,17 +166,44 @@ UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
   //    TList* fileSourcesHLT = GetFile(AliShuttleInterface::kHLT, "calib");
   //    const char* fileNameHLT = GetFile(AliShuttleInterface::kHLT, "calib", "LDC1");
 
+  // pedestal entries
 
   if(runType == kPedestalRunType) {
     Int_t pedestalSource = AliShuttleInterface::kDAQ;
     TString source = fConfEnv->GetValue("Pedestal","DAQ");
     source.ToUpper();
     if ( source == "HLT" ) pedestalSource = AliShuttleInterface::kHLT;
+    if (!GetHLTStatus()) pedestalSource = AliShuttleInterface::kDAQ;
     UInt_t pedestalResult = ExtractPedestals(pedestalSource);
     result += pedestalResult;
 
   }
 
+  // pulser trigger processing
+
+  if( runType == kPulserRunType ) {
+    Int_t pulserSource = AliShuttleInterface::kDAQ;
+    TString source = fConfEnv->GetValue("Pulser","DAQ");
+    source.ToUpper();
+    if ( source == "HLT" ) pulserSource = AliShuttleInterface::kHLT;
+    if (!GetHLTStatus()) pulserSource = AliShuttleInterface::kDAQ;
+    UInt_t pulserResult = ExtractPulser(pulserSource);
+    result += pulserResult;
+
+  }
+
+  // Central Electrode processing
+
+  if( false ) {    // CE input file not generated yet
+    Int_t ceSource = AliShuttleInterface::kDAQ;
+    TString source = fConfEnv->GetValue("CE","DAQ");
+    source.ToUpper();
+    if ( source == "HLT" ) ceSource = AliShuttleInterface::kHLT;
+    if (!GetHLTStatus()) ceSource = AliShuttleInterface::kDAQ;
+    UInt_t ceResult = ExtractCE(ceSource);
+    result += ceResult;
+
+  }
 
   return result;
 }
@@ -273,7 +303,8 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 
  Int_t nSectors = fROC->GetNSectors();
  TList* list = GetFileSources(sourceFXS,"pedestals");
- if (list) {
+ if (list && list->GetEntries()>0) {
 
 //  loop through all files from LDCs
 
@@ -284,6 +315,11 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
         TString fileName = GetFile(sourceFXS, "pedestals",
                                         fileNameEntry->GetString().Data());
         TFile *f = TFile::Open(fileName);
+        if (!f) {
+         Log ("Error opening pedestal file.");
+         result =2;
+         break;
+       }
         AliTPCCalibPedestal *calPed;
        f->GetObject("AliTPCCalibPedestal",calPed);
 
@@ -311,6 +347,9 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
     storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
     if ( !storeOK ) ++result;
 
+  } else {
+    Log ("Error: no entries!");
+    result = 1;
   }
 
   return result;
@@ -319,3 +358,182 @@ UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
 //______________________________________________________________________________________________
 
 
+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=0;
+ AliTPCCalPad *pulserTmean=0;
+ AliTPCCalPad *pulserTrms=0;
+ AliTPCCalPad *pulserQmean=0;
+ AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
+ if (entry) pulserObjects = (TObjArray*)entry->GetObject();
+ if ( pulserObjects==NULL ) {
+     Log("AliTPCPreprocsessor: No previous TPC pulser entry available.\n");
+     pulserObjects = new TObjArray;    
+ }
+
+ pulserTmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserTmean");
+ if ( !pulserTmean ) {
+    pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
+    pulserObjects->Add(pulserTmean);
+ }
+ pulserTrms = (AliTPCCalPad*)pulserObjects->FindObject("PulserTrms");
+ if ( !pulserTrms )  { 
+    pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
+    pulserObjects->Add(pulserTrms);
+ }
+ pulserQmean = (AliTPCCalPad*)pulserObjects->FindObject("PulserQmean");
+ if ( !pulserQmean )  { 
+    pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
+    pulserObjects->Add(pulserQmean);
+ }
+
+
+ UInt_t result=0;
+
+ Int_t nSectors = fROC->GetNSectors();
+ TList* list = GetFileSources(sourceFXS,"pulser");
+ 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, "pulser",
+                                        fileNameEntry->GetString().Data());
+        TFile *f = TFile::Open(fileName);
+        if (!f) {
+         Log ("Error opening pulser file.");
+         result =2;
+         break;
+       }
+        AliTPCCalibPulser *calPulser;
+       f->GetObject("AliTPCCalibPulser",calPulser);
+
+        //  replace entries for the sectors available in the present file
+
+        for (Int_t sector=0; sector<nSectors; sector++) {
+           AliTPCCalROC *rocTmean=calPulser->GetCalRocT0(sector);
+           if ( rocTmean )  pulserTmean->SetCalROC(rocTmean,sector);
+           AliTPCCalROC *rocTrms=calPulser->GetCalRocRMS(sector);
+           if ( rocTrms )  pulserTrms->SetCalROC(rocTrms,sector);
+           AliTPCCalROC *rocQmean=calPulser->GetCalRocQ(sector);
+           if ( rocQmean )  pulserQmean->SetCalROC(rocQmean,sector);
+        }
+      }
+     ++index;
+    }  // while(list)
+//
+//  Store updated pedestal entry to OCDB
+//
+    AliCDBMetaData metaData;
+    metaData.SetBeamPeriod(0);
+    metaData.SetResponsible("Haavard Helstrup");
+    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!");
+    result = 1;
+  }
+
+  return result;
+}
+
+UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
+{
+ //
+ //  Read Central Electrode file from file exchage server
+ //  Keep original entry from OCDB in case no new CE calibration is available
+ //
+ TObjArray    *ceObjects=0;
+ AliTPCCalPad *ceTmean=0;
+ AliTPCCalPad *ceTrms=0;
+ AliTPCCalPad *ceQmean=0;
+ AliCDBEntry* entry = GetFromOCDB("Calib", "CE");
+ if (entry) ceObjects = (TObjArray*)entry->GetObject();
+ if ( ceObjects==NULL ) {
+     Log("AliTPCPreprocsessor: No previous TPC central electrode entry available.\n");
+     ceObjects = new TObjArray;    
+ }
+
+ ceTmean = (AliTPCCalPad*)ceObjects->FindObject("CETmean");
+ if ( !ceTmean ) {
+    ceTmean = new AliTPCCalPad("CETmean","CETmean");
+    ceObjects->Add(ceTmean);
+ }
+ ceTrms = (AliTPCCalPad*)ceObjects->FindObject("CETrms");
+ if ( !ceTrms )  { 
+    ceTrms = new AliTPCCalPad("CETrms","CETrms");
+    ceObjects->Add(ceTrms);
+ }
+ ceQmean = (AliTPCCalPad*)ceObjects->FindObject("CEQmean");
+ if ( !ceQmean )  { 
+    ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
+    ceObjects->Add(ceQmean);
+ }
+
+
+ UInt_t result=0;
+
+ Int_t nSectors = fROC->GetNSectors();
+ 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());
+        TFile *f = TFile::Open(fileName);
+        if (!f) {
+         Log ("Error opening central electrode file.");
+         result =2;
+         break;
+       }
+        AliTPCCalibCE *calCE;
+       f->GetObject("AliTPCCalibCE",calCE);
+
+        //  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);
+        }
+      }
+     ++index;
+    }  // while(list)
+//
+//  Store updated pedestal entry to OCDB
+//
+    AliCDBMetaData metaData;
+    metaData.SetBeamPeriod(0);
+    metaData.SetResponsible("Haavard Helstrup");
+    metaData.SetComment("Preprocessor AliTPC data base entries.");
+
+    Bool_t storeOK = Store("Calib", "CE", ceObjects, &metaData, 0, kTRUE);
+    if ( !storeOK ) ++result;
+    
+  } else {
+    Log ("Error: no entries!");
+    result = 1;
+  }
+
+  return result;
+}
index a62df90..55849a2 100644 (file)
@@ -25,6 +25,8 @@ class AliTPCPreprocessor : public AliPreprocessor
     UInt_t  MapTemperature(TMap* dcsAliasMap);
     UInt_t  MapPressure(TMap* dcsAliasMap);
     UInt_t  ExtractPedestals(Int_t sourceFXS);
+    UInt_t  ExtractPulser(Int_t sourceFXS);
+    UInt_t  ExtractCE(Int_t sourceFXS);
     AliTPCPreprocessor& operator = (const AliTPCPreprocessor& rhs);
 
   private: