31-may-2007 NvE Memberfunctions GetNdevices, GetIdDevice and ShowDevices of AliEvent
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 1 Jun 2007 16:01:48 +0000 (16:01 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 1 Jun 2007 16:01:48 +0000 (16:01 +0000)
                extended to select device classes.
01-jul-2007 NvE Memberfunction GetString() introduced in class IceGOM.
                IceCalibrate.cxx and IceXtalk.cxx updated to support both the old (MuDaq only)
                and new (MuDaq, TWRDaq, ...) calibration file format.
                Also isolation cut in IceCleanHits modified to ignore hits from
                the same OM.
01-jul-2007 NvE Class IceCal2Root extended to support various databases (e.g. MuDaq, TWRDaq, ...).

15 files changed:
RALICE/AliEvent.cxx
RALICE/AliEvent.h
RALICE/history.txt
RALICE/icepack/IceCalibrate.cxx
RALICE/icepack/IceCleanHits.cxx
RALICE/icepack/IceGOM.cxx
RALICE/icepack/IceGOM.h
RALICE/icepack/IceXtalk.cxx
RALICE/icepack/history.txt
RALICE/icepack/iceconvert/IceCal2Root.cxx
RALICE/icepack/iceconvert/IceCal2Root.h
RALICE/icepack/iceconvert/IceRoot.h
RALICE/icepack/iceconvert/history.txt
RALICE/icepack/iceconvert/macros/Analyse.cxx
RALICE/icepack/iceconvert/macros/icecal2root.cc

index 145465c..1bf159c 100644 (file)
@@ -690,6 +690,21 @@ Int_t AliEvent::GetNdevices() const
  return ndevs;
 } 
 ///////////////////////////////////////////////////////////////////////////
+Int_t AliEvent::GetNdevices(const char* classname) const
+{
+// Provide the number of stored devices of the specified class.
+
+ Int_t ndevs=0;
+ for (Int_t idev=1; idev<=GetNdevices(); idev++)
+ {
+  TObject* obj=GetDevice(idev);
+  if (!obj) continue;
+
+  if (obj->InheritsFrom(classname)) ndevs++;
+ }
+ return ndevs;
+} 
+///////////////////////////////////////////////////////////////////////////
 void AliEvent::AddDevice(TObject& d)
 {
 // Add a device to the event.
@@ -830,9 +845,38 @@ TObject* AliEvent::GetDevice(TString name) const
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-TObject* AliEvent::GetIdDevice(Int_t id) const
+TObject* AliEvent::GetIdDevice(Int_t id,TObjArray* devs) const
 {
-// Return the device with unique identifier "id".
+// Return the device with identifier "id" from the specified array "devs".
+// In case devs=0 (which is the default) all devices stored in the event
+// structure will be evaluated.
+// Note : In case of multiple occurrences of identifier "id", the first
+//        encountered matching device will be returned.
+
+ TObjArray* arr=devs;
+ if (!arr) arr=fDevices;
+
+ if (!arr || id<0) return 0;
+
+ Int_t idx=0;
+ for (Int_t i=0; i<arr->GetSize(); i++)
+ {
+  TObject* dev=arr->At(i);
+  if (dev)
+  {
+   idx=dev->GetUniqueID();
+   if (idx==id) return dev;
+  }
+ }
+ return 0; // No matching id found
+}
+///////////////////////////////////////////////////////////////////////////
+TObject* AliEvent::GetIdDevice(Int_t id,const char* classname) const
+{
+// Return the device with identifier "id" of the specified class.
+// Note : In case of multiple occurrences of identifier "id", the first
+//        encountered matching device will be returned.
+
  if (!fDevices || id<0) return 0;
 
  Int_t idx=0;
@@ -842,10 +886,10 @@ TObject* AliEvent::GetIdDevice(Int_t id) const
   if (dev)
   {
    idx=dev->GetUniqueID();
-   if (idx==id) return dev;
+   if (idx==id && dev->InheritsFrom(classname)) return dev;
   }
  }
- return 0; // No matching id found
+ return 0; // No matching id found for the specified class
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliEvent::ShowDevices(Int_t mode) const
@@ -867,6 +911,7 @@ void AliEvent::ShowDevices(Int_t mode) const
   else
   {
    cout << " The following " << ndevs << " devices are available :" << endl; 
+   Int_t nh=0,nw=0;
    for (Int_t i=1; i<=ndevs; i++)
    {
     TObject* dev=GetDevice(i);
@@ -876,8 +921,16 @@ void AliEvent::ShowDevices(Int_t mode) const
      cout << " Device number : " << i;
      cout << " Class : " << dev->ClassName() << " Id : " << dev->GetUniqueID();
      if (strlen(name)) cout << " Name : " << name;
-     if (dev->InheritsFrom("AliDevice")) cout << " Nhits : " << ((AliDevice*)dev)->GetNhits();
-     if (dev->InheritsFrom("AliSignal")) cout << " Nwaveforms : " << ((AliSignal*)dev)->GetNwaveforms();
+     if (dev->InheritsFrom("AliDevice"))
+     {
+      nh=((AliDevice*)dev)->GetNhits();
+      if (nh) cout << " Nhits : " << nh;
+     }
+     if (dev->InheritsFrom("AliSignal"))
+     {
+      nw=((AliSignal*)dev)->GetNwaveforms();
+      if (nw) cout << " Nwaveforms : " << nw;
+     }
      cout << endl;
     }
    }
@@ -889,6 +942,60 @@ void AliEvent::ShowDevices(Int_t mode) const
  }
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliEvent::ShowDevices(const char* classname,Int_t mode) const
+{
+// Provide an overview of the available devices of the specified class.
+// The argument mode determines the amount of information as follows :
+// mode = 0 ==> Only printout of the number of devices
+//        1 ==> Provide a listing with 1 line of info for each device
+//
+// The default is mode=1.
+//
+ Int_t ndevs=GetNdevices();
+ if (ndevs)
+ {
+  Int_t ndevs2=GetNdevices(classname);
+  if (!mode || !ndevs2)
+  {
+   cout << " There are " << ndevs2 << " selected devices available." << endl; 
+  }
+  else
+  {
+   cout << " The following " << ndevs2 << " selected devices are available :" << endl; 
+   Int_t nh=0,nw=0;
+   for (Int_t i=1; i<=ndevs; i++)
+   {
+    TObject* dev=GetDevice(i);
+    if (dev)
+    {
+     if (dev->InheritsFrom(classname))
+     {
+      const char* name=dev->GetName();
+      cout << " Device number : " << i;
+      cout << " Class : " << dev->ClassName() << " Id : " << dev->GetUniqueID();
+      if (strlen(name)) cout << " Name : " << name;
+      if (dev->InheritsFrom("AliDevice"))
+      {
+       nh=((AliDevice*)dev)->GetNhits();
+       if (nh) cout << " Nhits : " << nh;
+      }
+      if (dev->InheritsFrom("AliSignal"))
+      {
+       nw=((AliSignal*)dev)->GetNwaveforms();
+       if (nw) cout << " Nwaveforms : " << nw;
+      }
+      cout << endl;
+     }
+    }
+   }
+  }
+ }
+ else
+ {
+  cout << " No devices present for this event." << endl;
+ }
+}
+///////////////////////////////////////////////////////////////////////////
 TObjArray* AliEvent::GetDevices(const char* classname)
 {
 // Provide the references to the various devices derived from the
index a6d49c9..8142e15 100644 (file)
@@ -50,11 +50,14 @@ class AliEvent : public AliVertex,public AliTimestamp
   void AddDevice(TObject& d);             // Add a device to the event
   void AddDevice(TObject* d) { if (d) AddDevice(*d); }
   Int_t GetNdevices() const;              // Provide the number of devices
+  Int_t GetNdevices(const char* classname) const; // Provide the number of selected devices
   void ShowDevices(Int_t mode=1) const;   // Provide on overview of the available devices
+  void ShowDevices(const char* classname,Int_t mode=1) const; // Overview of selected devices
   TObjArray* GetDevices(const char* classname); // Provide references to the devices derived from the specified class
   TObject* GetDevice(Int_t i) const;      // Provide i-th device of the event
   TObject* GetDevice(TString name) const; // Provide the device with name "name"
-  TObject* GetIdDevice(Int_t id) const;   // Provide the device with unique identifier "id"
+  TObject* GetIdDevice(Int_t id, TObjArray* devs=0) const; // Get device with identifier "id"
+  TObject* GetIdDevice(Int_t id, const char* classname) const; // Get device with identifier "id" of specified class
   Int_t GetNhits(const char* classname);  // Provide number of hits for the specified device class
   TObjArray* GetHits(const char* classname); // Provide refs to all hits of the specified device class 
   AliSignal* GetIdHit(Int_t id,const char* classname); // Provide hit with unique "id" for the specified device class
@@ -80,6 +83,6 @@ class AliEvent : public AliVertex,public AliTimestamp
   TObject* fDisplay;                    //! Temp. pointer to hold objects which serve event displays
   TObjArray* fDevs;                     //! Temp. array to hold references to user selected devices
 
- ClassDef(AliEvent,23) // Creation and investigation of an Alice physics event.
+ ClassDef(AliEvent,24) // Creation and investigation of an Alice physics event.
 };
 #endif
index 14e8232..5f807f7 100644 (file)
                 specification of negative "mode" parameter.
 29-mar-2007 NvE New memberfunction Almanac() introduced in AliTimestamp to provide a 
                 central place for calculation of astronomical observables.
+31-may-2007 NvE Memberfunctions GetNdevices, GetIdDevice and ShowDevices of AliEvent
+                extended to select device classes.
index 7e7443a..54bf99f 100644 (file)
@@ -84,10 +84,6 @@ void IceCalibrate::SetCalibFile(TString name)
 // Set the calibration ROOT file as created with IceCal2Root.
 // Note : this will overrule a previously attached database. 
  fCalfile=new TFile(name.Data());
- if (fCalfile)
- {
-  fOmdb=(AliObjMatrix*)fCalfile->Get("Cal-OMDBASE");
- }
 }
 ///////////////////////////////////////////////////////////////////////////
 void IceCalibrate::Exec(Option_t* opt)
@@ -102,6 +98,23 @@ void IceCalibrate::Exec(Option_t* opt)
  IceEvent* evt=(IceEvent*)parent->GetObject("IceEvent");
  if (!evt) return;
 
+ Int_t mudaq=0;
+ Int_t twrdaq=0;
+ AliSignal* daq=(AliSignal*)evt->GetDevice("Daq");
+ mudaq=daq->GetSignal("Muon");
+ twrdaq=daq->GetSignal("TWR");
+
+ if (fCalfile)
+ {
+  if (mudaq)
+  {
+   fOmdb=(AliObjMatrix*)fCalfile->Get("MuDaq-OMDBASE");
+   // Next statement for compatibility with old calibration file format
+   if (!fOmdb) fOmdb=(AliObjMatrix*)fCalfile->Get("Cal-OMDBASE");
+  }
+  if (twrdaq) fOmdb=(AliObjMatrix*)fCalfile->Get("TWRDaq-OMDBASE");
+ }
+
  // Storage of the used parameters in the IceCalibrate device
  AliSignal params;
  params.SetNameTitle("IceCalibrate","IceCalibrate processor parameters");
@@ -190,33 +203,44 @@ void IceCalibrate::Exec(Option_t* opt)
     fcal=omd->GetCalFunction("LE");
     fdecal=omd->GetDecalFunction("LE");
    }
-   // Store the hit-specific ADC dependent (de)calibration function in the hit itself
-   sx->SetCalFunction(fcal,"LE");
-   sx->SetDecalFunction(fdecal,"LE");
-   fcal=sx->GetCalFunction("LE");
-   fdecal=sx->GetDecalFunction("LE");
-   if (adc>0)
-   {
-    if (fcal) fcal->SetParameter(3,adc);
-    if (fdecal) fdecal->SetParameter(3,adc);
-   }
-   else
+
+   // MuDaq only : Store the hit-specific ADC dependent (de)calibration function in the hit itself
+   if (mudaq)
    {
-    if (fcal) fcal->SetParameter(3,1.e20);
-    if (fdecal) fdecal->SetParameter(3,1.e20);
+    sx->SetCalFunction(fcal,"LE");
+    sx->SetDecalFunction(fdecal,"LE");
+    fcal=sx->GetCalFunction("LE");
+    fdecal=sx->GetDecalFunction("LE");
+    if (adc>0)
+    {
+     if (fcal) fcal->SetParameter(3,adc);
+     if (fdecal) fdecal->SetParameter(3,adc);
+    }
+    else
+    {
+     if (fcal) fcal->SetParameter(3,1.e20);
+     if (fdecal) fdecal->SetParameter(3,1.e20);
+    }
    }
+
    if (fcal) // Store calibrated signal
    {
     cle=fcal->Eval(le);
     sx->SetSignal(cle,"LE");
-    sx->SetCalFunction(0,"LE");
-    sx->SetDecalFunction(fdecal,"LE");
+    if (mudaq) // MuDaq only
+    {
+     sx->SetCalFunction(0,"LE");
+     sx->SetDecalFunction(fdecal,"LE");
+    }
    }
    else // Store uncalibrated signal
    {
     sx->SetSignal(le,"LE");
-    sx->SetCalFunction(fcal,"LE");
-    sx->SetDecalFunction(0,"LE");
+    if (mudaq) // MuDaq only
+    {
+     sx->SetCalFunction(fcal,"LE");
+     sx->SetDecalFunction(0,"LE");
+    }
    }
 
    // TOT (de)calibration
@@ -266,7 +290,9 @@ void IceCalibrate::Exec(Option_t* opt)
    ome->SetDecalFunction(0,"ADC");
   }
 
-  // Store ADC independent LE (de)calibration function in this OM according to dbase info
+  // Store LE (de)calibration function in this OM according to dbase info
+  // Note for MuDaq only : This is the ADC independent function.
+  //                       The ADC dependent calibration function is in the hits themselves
   fcal=0;
   fdecal=0;
   if (omd)
index e53c67e..24b1238 100644 (file)
@@ -28,7 +28,7 @@
 // 2) TOT within [min,max]  Default : electrical [125,2000] optical [20,2000] ns
 // 3) abs(LE-Ttrig)<=win    Default : win=2250 TDC counts
 //    where : LE=uncalibrated hit LE (i.e. TDC counts)   Ttrig=trigger pulse LE in TDC counts
-// 4) At least one other hit within radius R and time difference dt
+// 4) At least one hit in another OM within radius R and time difference dt
 //    to remove isolated hits. Defaults : R=70 m  dt=500 ns
 //
 // The defaults of the various parameters can be changed by the corresponding
@@ -280,7 +280,7 @@ void IceCleanHits::Amanda()
  }
  
  // Isolation cut
- // Only retain hits that have at least one other hit within a certain
+ // Only retain hits that have at least one hit of another OM within a certain
  // radius and within a certain time window
  Int_t nhits=hits.GetEntries();
  AliSignal* sx1=0;
@@ -296,22 +296,22 @@ void IceCleanHits::Amanda()
  {
   sx1=(AliSignal*)hits.At(jh1);
   if (!sx1) continue;
+
   iso=1;
   for (Int_t jh2=0; jh2<nhits; jh2++)
   {
-   if (jh1==jh2)
-   {
-    iso=0;
-    continue;
-   }
    sx2=(AliSignal*)hits.At(jh2);
    if (!sx2) continue;
+
+   omx1=(IceAOM*)sx1->GetDevice();
+   omx2=(IceAOM*)sx2->GetDevice();
+   if (omx1==omx2) continue;
+
    t1=sx1->GetSignal("LE",7);
    t2=sx2->GetSignal("LE",7);
    dt=fabs(t2-t1);
    if (dt>fDtmaxA) continue;
-   omx1=(IceAOM*)sx1->GetDevice();
-   omx2=(IceAOM*)sx2->GetDevice();
+
    if (omx1 && omx2)
    {
     r1=omx1->GetPosition();
index 098f8e8..9483a36 100644 (file)
@@ -130,6 +130,47 @@ IceGOM::IceGOM(const IceGOM& m) : AliDevice(m)
 // Copy constructor.
 }
 ///////////////////////////////////////////////////////////////////////////
+Int_t IceGOM::GetString() const
+{
+// Provide the corresponding string number for this module.
+// Note : Amanda string numbers will have negative values.
+
+ Int_t omid=GetUniqueID();
+
+ if (omid<=0) return 0;
+ if (omid==681) return -18;
+
+ Int_t string=0;
+ if (InheritsFrom("IceAOM"))
+ {
+  if (omid<=20) return -1;
+  if (omid>=21 && omid<=40) return -2;
+  if (omid>=41 && omid<=60) return -3;
+  if (omid>=61 && omid<=86) return -4;
+  if (omid>=87 && omid<=122) return -5;
+  if (omid>=123 && omid<=158) return -6;
+  if (omid>=159 && omid<=194) return -7;
+  if (omid>=195 && omid<=230) return -8;
+  if (omid>=231 && omid<=266) return -9;
+  if (omid>=267 && omid<=302) return -10;
+  if (omid>=303 && omid<=344) return -11;
+  if (omid>=345 && omid<=386) return -12;
+  if (omid>=387 && omid<=428) return -13;
+  if (omid>=429 && omid<=470) return -14;
+  if (omid>=471 && omid<=512) return -15;
+  if (omid>=513 && omid<=554) return -16;
+  if (omid>=555 && omid<=596) return -17;
+  if (omid>=597 && omid<=638) return -18;
+  if (omid>=639 && omid<=680) return -19;
+ }
+ else
+ {
+  string=omid/100;
+ }
+
+ return string;
+}
+///////////////////////////////////////////////////////////////////////////
 TObject* IceGOM::Clone(const char* name) const
 {
 // Make a deep copy of the current object and provide the pointer to the copy.
index 7b7bdf3..9cd7f5b 100644 (file)
@@ -15,7 +15,8 @@ class IceGOM : public AliDevice
   virtual ~IceGOM();                                 // Default destructor
   IceGOM(const IceGOM& m);                           // Copy constructor
   virtual TObject* Clone(const char* name="") const; // Make a deep copy and provide its pointer
+  Int_t GetString() const;                           // Provide the corresponding string number
 
- ClassDef(IceGOM,1) // Signal (Hit) handling of a generic IceCube Optical Module (GOM).
+ ClassDef(IceGOM,2) // Signal (Hit) handling of a generic IceCube Optical Module (GOM).
 };
 #endif
index a854014..0994ffa 100644 (file)
@@ -19,6 +19,8 @@
 // Class IceXtalk
 // TTask derived class to perform cross talk hit correction.
 //
+// Note : This processor only acts on MuDaq data.
+//
 // This task takes the current event in memory and uses the attached
 // OM database to identify pairs of OMs which might induce cross talk.
 // For each particular transmitter and receiver pair within the event
@@ -110,10 +112,6 @@ void IceXtalk::SetCalibFile(TString name)
 // Set the calibration ROOT file as created with IceCal2Root.
 // Note : this will overrule a previously attached database. 
  fCalfile=new TFile(name.Data());
- if (fCalfile)
- {
-  fOmdb=(AliObjMatrix*)fCalfile->Get("Cal-OMDBASE");
- }
 }
 ///////////////////////////////////////////////////////////////////////////
 void IceXtalk::SetMinProb(Float_t pmin)
@@ -132,8 +130,6 @@ void IceXtalk::Exec(Option_t* opt)
 {
 // Implementation of cross talk hit correction.
 
- if (!fOmdb) return;
-
  TString name=opt;
  AliJob* parent=(AliJob*)(gROOT->GetListOfTasks()->FindObject(name.Data()));
 
@@ -142,6 +138,24 @@ void IceXtalk::Exec(Option_t* opt)
  IceEvent* evt=(IceEvent*)parent->GetObject("IceEvent");
  if (!evt) return;
 
+ Int_t mudaq=0;
+ Int_t twrdaq=0;
+ AliSignal* daq=(AliSignal*)evt->GetDevice("Daq");
+ mudaq=daq->GetSignal("Muon");
+ twrdaq=daq->GetSignal("TWR");
+
+ // This cross talk correction processor is only for MuDaq data 
+ if (!mudaq) return;
+
+ if (fCalfile)
+ {
+  fOmdb=(AliObjMatrix*)fCalfile->Get("MuDaq-OMDBASE");
+  // Next statement for compatibility with old calibration file format
+  if (!fOmdb) fOmdb=(AliObjMatrix*)fCalfile->Get("Cal-OMDBASE");
+ }
+
+ if (!fOmdb) return;
+
  // Storage of the used parameters in the IceXtalk device
  AliSignal params;
  params.SetNameTitle("IceXtalk","IceXtalk processor parameters");
index 7bb4f9b..acbfaa5 100644 (file)
                 obsolete due to bug fix in IceRawTWR.
 28-mar-2007 NvE Explicitly included TMath.h in IceChi2.h and IcePandel.h due to a
                 ROOT restructuring introduced in version 5.15/04.
+01-jul-2007 NvE Memberfunction GetString() introduced in class IceGOM.
+                IceCalibrate.cxx and IceXtalk.cxx updated to support both the old (MuDaq only)
+                and new (MuDaq, TWRDaq, ...) calibration file format.
+                Also isolation cut in IceCleanHits modified to ignore hits from
+                the same OM.
                  
index 3bd76b5..2866992 100644 (file)
 
 ///////////////////////////////////////////////////////////////////////////
 // Class IceCal2Root
-// Conversion of Amanda ascii calibration data into an AliObjMatrix object
+// Conversion of Amanda (ascii) calibration data into a AliObjMatrix objects
 // containing the complete OM position, calibration, Xtalk etc... database.
+// Via specification of the various input files, various AliObjMatrix objects
+// are created and (optionally) stored in a single output file.
+// The names of the AliObjMatrix objects indicate the type of database they
+// contain.
+// For example :
+// The name "MuDaq-OMDBASE" indicates the database info for MuDaq data,
+// whereas TWRDaq calibration data is in the object named "TWRDaq-OMDBASE".
+// Note that a MuDaq Amacalib ascii input file has always to be provided,
+// since the geometry data for all the other databases is obtained from there.   
 // In addition a PDG particle database, extended with some specific Amanda
 // entries, is provided as well.
 // This class is derived from AliJob providing task-based processing.
-// The main object in the job environment is an AliObjMatrix* pointer
-// which contains the OM database.
 // Note that the data structures are only written out if an outputfile has
 // been specified via the SetOutputFile memberfunction.
 // In case no outputfile has been specified, this class provides a facility
@@ -35,6 +42,8 @@
 // (j,k+1)  : Pointer to a TF1* being the probability function for Xtalk
 //            with OM "j" as transmitter and OM "k" as receiver.
 //
+// The latter is only available for MuDaq databases.
+//
 // The geometry information is directly available from the OM pointer
 // in the form of its position and data words like "ORIENT" for orientation etc...
 // Just use the OM memberfunction Data() to obtain a full overview. 
 //
 // IceCal2Root q("IceCal2Root","Amacalib to IcePack data structure conversion");
 //
-// // The Amacalib input filename
-// q.SetAmacalibFile("amacalib_amanda2_2003.txt");
+// // The MuDaq Amacalib input filename
+// q.SetAmacalibFile("amacalib_amanda2_2005.txt");
+//
+// // The TWRDaq input filename with the newly determined TWR T0's.
+// q.SetTWRDaqFile("muon_t0_cal_2005.txt");
 //
 // // Output file for the event structures
-// q.SetOutputFile("calib2003.root");
+// q.SetOutputFile("cal2005.root");
 //
 // ///////////////////////////////////////////////////////////////////
 // // Here the user can specify his/her sub-tasks to be executed
 //
 // // Outline of dbase usage for (de)calibration and Xtalk
 //
-// AliObjMatrix* omdb=q.GetOMdbase();
+// AliObjMatrix* omdb=q.GetOMdbase("MuDaq");
 // IceAOM* om=(IceAOM*)omdb->GetObject(9,1); // Pointer to OM 9
 // om->Data(); // Overview of generic module parameters
 // TF1* fcal=0;   // Calibration function
@@ -158,11 +170,13 @@ IceCal2Root::IceCal2Root(const char* name,const char* title) : AliJob(name,title
 {
 // Default constructor.
  fAmacalFileName="";
+ fTWRDaqFileName="";
  fRootFileName="";
  fOutfile=0;
 
  fPdg=0;
- fOmdb=0;
+ fMuDaqdb=0;
+ fTWRDaqdb=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 IceCal2Root::~IceCal2Root()
@@ -175,19 +189,31 @@ IceCal2Root::~IceCal2Root()
   fPdg=0;
  }
 
- if (fOmdb)
+ if (fMuDaqdb)
  {
-  delete fOmdb;
-  fOmdb=0;
+  delete fMuDaqdb;
+  fMuDaqdb=0;
+ }
+
+ if (fTWRDaqdb)
+ {
+  delete fTWRDaqdb;
+  fTWRDaqdb=0;
  }
 }
 ///////////////////////////////////////////////////////////////////////////
 void IceCal2Root::SetAmacalibFile(TString name)
 {
-// Set the name of the Amacalib input file.
+// Set the name of the Amacalib MuDaq input file.
  fAmacalFileName=name;
 }
 ///////////////////////////////////////////////////////////////////////////
+void IceCal2Root::SetTWRDaqFile(TString name)
+{
+// Set the name of the TWRDaq calibration input file.
+ fTWRDaqFileName=name;
+}
+///////////////////////////////////////////////////////////////////////////
 void IceCal2Root::SetOutputFile(TString name)
 {
 // Set the name of the ROOT output file.
@@ -200,41 +226,33 @@ TDatabasePDG* IceCal2Root::GetPDG()
  return fPdg;
 }
 ///////////////////////////////////////////////////////////////////////////
-AliObjMatrix* IceCal2Root::GetOMdbase()
+AliObjMatrix* IceCal2Root::GetOMdbase(TString name)
 {
-// Provide pointer to the OM geometry, calib. etc... database
- return fOmdb;
+// Provide pointer to the requested OM geometry, calib. etc... database.
+// Options for the "name" specification are : MuDaq, TWRDaq.
+// For backward compatibility the default is name="MuDaq".
+
+ if (name=="MuDaq") return fMuDaqdb;
+ if (name=="TWRDaq") return fTWRDaqdb;
+ return 0;
 }
 ///////////////////////////////////////////////////////////////////////////
 void IceCal2Root::Exec(Option_t* opt)
 {
-// Job to convert the ascii database info into the IcePack structure.
+// Job to convert the (ascii) database info into the IcePack structure.
 //
 // Notes :
 // -------
 // 1) This class is derived from AliJob, allowing a task based processing.
-//    After conversion of the ascii dbase data into the IcePack structure,
+//    After conversion of the (ascii) dbase data into the IcePack structure,
 //    the processing of all available sub-tasks (if any) is invoked.
 //    This provides a facility to investigate/use the dbase data in
 //    subsequent (sub)tasks processing before the final data structures
 //    are written out.
-// 2) The main object in this job environment is an AliObjMatrix* pointer
-//    which contains the OM database.
-
- if (fAmacalFileName=="")
- {
-  cout << " *IceCal2Root Exec* No amacalib input file specified." << endl;
-  return;
- }
-
- fInput.clear();
- fInput.open(fAmacalFileName.Data());
-
- if (!fInput.good())
- {
-  cout << " *IceCal2Root Exec* Bad input file : " << fAmacalFileName.Data() << endl;
-  return;
- }
+//
+// 2) Creation of a TFolder via the argument of the ExecuteJob statement
+//    makes all created database objects accessible to subsequent tasks
+//    via the TFolder::FindObject facility.
 
  if (fOutfile)
  {
@@ -246,18 +264,6 @@ void IceCal2Root::Exec(Option_t* opt)
   fOutfile=new TFile(fRootFileName.Data(),"RECREATE","Calibration data in IcePack structure");
  }
 
- // The OM database object
- if (fOmdb)
- {
-  fOmdb->Reset();
- }
- else
- {
-  fOmdb=new AliObjMatrix();
-  fOmdb->SetNameTitle("Cal-OMDBASE","The OM geometry, calib. etc... database");
-  fOmdb->SetOwner();
- }
-
  // Create the particle database and extend it with some F2000 specific definitions
  if (fPdg) delete fPdg;
  fPdg=new TDatabasePDG();
@@ -276,19 +282,23 @@ void IceCal2Root::Exec(Option_t* opt)
  fPdg->AddParticle("a_primary","a_primary",0,1,0,0,"none",10003500,0,0);
 
  // Initialise the job working environment
- SetMainObject(fOmdb);
  AddObject(fPdg);
  if (fOutfile) AddObject(fOutfile);
 
  cout << " ***" << endl;
  cout << " *** Start processing of job " << GetName() << " ***" << endl;
  cout << " ***" << endl;
- cout << " Amacalib input file : " << fAmacalFileName.Data() << endl;
+ cout << " Amacalib MuDaq input file : " << fAmacalFileName.Data() << endl;
+ cout << " TWRDaq input file : " << fTWRDaqFileName.Data() << endl;
  if (fOutfile) cout << " ROOT output file : " << fOutfile->GetName() << endl;
 
- ListEnvironment();
+ GetMuDaqData();
+ if (fMuDaqdb) AddObject(fMuDaqdb);
 
- GetCalibData();
+ GetTWRDaqData();
+ if (fTWRDaqdb) AddObject(fTWRDaqdb);
+
+ ListEnvironment();
 
  // Invoke all available sub-tasks (if any)
  CleanTasks();
@@ -298,7 +308,8 @@ void IceCal2Root::Exec(Option_t* opt)
  if (fOutfile)
  {
   fOutfile->cd();
-  if (fOmdb) fOmdb->Write();
+  if (fMuDaqdb) fMuDaqdb->Write();
+  if (fTWRDaqdb) fTWRDaqdb->Write();
   if (fPdg) fPdg->Write();
  }
 
@@ -306,9 +317,36 @@ void IceCal2Root::Exec(Option_t* opt)
  if (fOutfile) fOutfile->Write();
 }
 ///////////////////////////////////////////////////////////////////////////
-void IceCal2Root::GetCalibData()
+void IceCal2Root::GetMuDaqData()
 {
-// Obtain all the geometry, calibration and Xtalk data.
+// Obtain all the MuDaq geometry, calibration and Xtalk data.
+
+ if (fAmacalFileName=="")
+ {
+  cout << " *IceCal2Root GetMuDaqData* No amacalib input file specified." << endl;
+  return;
+ }
+
+ fInput.clear();
+ fInput.open(fAmacalFileName.Data());
+
+ if (!fInput.good())
+ {
+  cout << " *IceCal2Root GetMuDaqData* Bad input file : " << fAmacalFileName.Data() << endl;
+  return;
+ }
+
+ // The MuDaq OM database object
+ if (fMuDaqdb)
+ {
+  fMuDaqdb->Reset();
+ }
+ else
+ {
+  fMuDaqdb=new AliObjMatrix();
+  fMuDaqdb->SetNameTitle("MuDaq-OMDBASE","The MuDaq OM geometry, calib. etc... database");
+  fMuDaqdb->SetOwner();
+ }
 
  // Prescription of the various (de)calibration functions
  TF1 fadccal("fadccal","(x-[1])*[0]");
@@ -376,12 +414,12 @@ void IceCal2Root::GetCalibData()
   if (s == "P") // Read the Geom data
   {
    fInput >> jmod >> type >> serial >> string >> ix >> iy >> iz >> ori;
-   omx=(IceAOM*)fOmdb->GetObject(jmod,1);
+   omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1);
    if (!omx)
    {
     omx=new IceAOM(om);
     omx->SetUniqueID(jmod);
-    fOmdb->EnterObject(jmod,1,omx);
+    fMuDaqdb->EnterObject(jmod,1,omx);
    }
    pos[0]=double(ix)/1000.;
    pos[1]=double(iy)/1000.;
@@ -397,12 +435,12 @@ void IceCal2Root::GetCalibData()
   else if (s == "T") // Read the Time calibration constants
   {
    fInput >> jmod >> ped >> beta >> alpha >> pol;
-   omx=(IceAOM*)fOmdb->GetObject(jmod,1);
+   omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1);
    if (!omx)
    {
     omx=new IceAOM(om);
     omx->SetUniqueID(jmod);
-    fOmdb->EnterObject(jmod,1,omx);
+    fMuDaqdb->EnterObject(jmod,1,omx);
    }
 
    omx->SetCalFunction(&ftdccal,2);
@@ -453,12 +491,12 @@ void IceCal2Root::GetCalibData()
   else if (s == "A") // Read the Amplitude calibration constants
   {
    fInput >> jmod >> ped >> beta >> totped >> pol;
-   omx=(IceAOM*)fOmdb->GetObject(jmod,1);
+   omx=(IceAOM*)fMuDaqdb->GetObject(jmod,1);
    if (!omx)
    {
     omx=new IceAOM(om);
     omx->SetUniqueID(jmod);
-    fOmdb->EnterObject(jmod,1,omx);
+    fMuDaqdb->EnterObject(jmod,1,omx);
    }
 
    omx->SetCalFunction(&fadccal,1);
@@ -495,12 +533,12 @@ void IceCal2Root::GetCalibData()
   else if (s == "K") // Read the cross talk probability constants
   {
    fInput >> jtrans >> jrec >> c >> b >> dlemin >> dlemax;
-   omx=(IceAOM*)fOmdb->GetObject(jtrans,1);
+   omx=(IceAOM*)fMuDaqdb->GetObject(jtrans,1);
    if (!omx)
    {
     omx=new IceAOM(om);
     omx->SetUniqueID(jtrans);
-    fOmdb->EnterObject(jtrans,1,omx);
+    fMuDaqdb->EnterObject(jtrans,1,omx);
    }
 
    TF1* fx=new TF1(fxtalkp);
@@ -515,12 +553,153 @@ void IceCal2Root::GetCalibData()
    }
    fx->SetParameter(2,dlemin);
    fx->SetParameter(3,dlemax);
-   fOmdb->EnterObject(jtrans,jrec+1,fx);
+   fMuDaqdb->EnterObject(jtrans,jrec+1,fx);
   }
   else // Skip this line
   {
    fInput.ignore(99999,'\n');
   } 
  }
+
+ fInput.close();
+}
+///////////////////////////////////////////////////////////////////////////
+void IceCal2Root::GetTWRDaqData()
+{
+// Obtain all the TWRDaq geometry and calibration data.
+
+ if (fTWRDaqFileName=="")
+ {
+  cout << " *IceCal2Root GetTWRDaqData* No TWRDaq calibration data will be produced." << endl;
+  return;
+ }
+
+ fInput.clear();
+ fInput.open(fTWRDaqFileName.Data());
+
+ if (!fInput.good())
+ {
+  cout << " *IceCal2Root GetTWRDaqData* Bad input file : " << fTWRDaqFileName.Data() << endl;
+  return;
+ }
+
+ // The geometry info will be obtained from the MuDaq OM database
+ if (!fMuDaqdb)
+ {
+  cout << " *IceCal2Root GetTWRDaqData* MuDaq OM geometry database is missing." << endl;
+  return;
+ }
+
+ // The TWRDaq OM database object
+ if (fTWRDaqdb)
+ {
+  fTWRDaqdb->Reset();
+ }
+ else
+ {
+  fTWRDaqdb=new AliObjMatrix();
+  fTWRDaqdb->SetNameTitle("TWRDaq-OMDBASE","The TWRDaq OM geometry, calib. etc... database");
+  fTWRDaqdb->SetOwner();
+ }
+
+ // Prescription of the various (de)calibration functions
+ TF1 fadccal("fadccal","(x-[0])*[1]");
+ TF1 fadcdecal("fadcdecal","(x/[1])+[0]");
+ fadccal.SetParName(0,"ADC-PED");
+ fadccal.SetParName(1,"ADC-FACT");
+ fadcdecal.SetParName(0,"ADC-PED");
+ fadcdecal.SetParName(1,"ADC-FACT");
+
+ TF1 ftdccal("ftdccal","x-[0]");
+ TF1 ftdcdecal("ftdcdecal","x+[0]");
+ ftdccal.SetParName(0,"T0");
+ ftdcdecal.SetParName(0,"T0");
+
+ TF1 ftotcal("ftotcal","x*[0]");
+ TF1 ftotdecal("ftotdecal","x/[0]");
+ ftotcal.SetParName(0,"TOT-FACT");
+ ftotdecal.SetParName(0,"TOT-FACT");
+
+ fInput.seekg(0); // Position at beginning of file
+ fInput >> dec;   // Make sure all integers starting with 0 are taken in decimal format
+
+ Int_t jmod;
+ Float_t t0;
+ IceAOM* omx=0;
+ TF1* fcal=0;
+ TF1* fdecal=0;
+ while (fInput >> jmod >> t0)
+ {
+  // Copy the Geom data from the MuDaq OM database
+  IceAOM* omg=(IceAOM*)fMuDaqdb->GetObject(jmod,1);
+  if (!omg) continue;
+
+  omx=new IceAOM(*omg);
+
+  // Reset all previous "dead" flags
+  omx->SetAlive("ADC");
+  omx->SetAlive("LE");
+  omx->SetAlive("TOT");
+
+  // Enter the TWRDaq (de)calibration functions
+  omx->SetCalFunction(&fadccal,"ADC");
+  omx->SetDecalFunction(&fadcdecal,"ADC");
+  omx->SetCalFunction(&ftdccal,"LE");
+  omx->SetDecalFunction(&ftdcdecal,"LE");
+  omx->SetCalFunction(&ftotcal,"TOT");
+  omx->SetDecalFunction(&ftotdecal,"TOT");
+
+  // Flag time slots of bad OMs as dead and don't provide time (de)calib functions
+  if (t0<-999)
+  {
+   omx->SetDead("LE");
+   omx->SetDead("TOT");
+   omx->SetCalFunction(0,"LE");
+   omx->SetDecalFunction(0,"LE");
+   omx->SetCalFunction(0,"TOT");
+   omx->SetDecalFunction(0,"TOT");
+  }
+
+  // Set the TWRDaq (de)calibration function parameters for the good OMs
+  fcal=omx->GetCalFunction("ADC");
+  fdecal=omx->GetDecalFunction("ADC");
+  if (fcal)
+  {
+   fcal->SetParameter(0,0);
+   fcal->SetParameter(1,1);
+  }
+  if (fdecal)
+  {
+   fdecal->SetParameter(0,0);
+   fdecal->SetParameter(1,1);
+  }
+
+  fcal=omx->GetCalFunction("LE");
+  fdecal=omx->GetDecalFunction("LE");
+  if (fcal)
+  {
+   fcal->SetParameter(0,t0);
+  }
+  if (fdecal)
+  {
+   fdecal->SetParameter(0,t0);
+  }
+
+  fcal=omx->GetCalFunction("TOT");
+  fdecal=omx->GetDecalFunction("TOT");
+  if (fcal)
+  {
+   fcal->SetParameter(0,1);
+  }
+  if (fdecal)
+  {
+   fdecal->SetParameter(0,1);
+  }
+
+  fTWRDaqdb->EnterObject(jmod,1,omx);
+
+ } // End of reading loop
+
+ fInput.close();
 }
 ///////////////////////////////////////////////////////////////////////////
index 6921c9a..4a3d77a 100644 (file)
@@ -22,25 +22,28 @@ class IceCal2Root : public AliJob
  public :
   IceCal2Root(const char* name="IceCal2Root",const char* title=""); // Constructor
   virtual ~IceCal2Root();                                           // Destructor
-  void SetAmacalibFile(TString name); // Set name of the Amacalib input file
+  void SetAmacalibFile(TString name); // Set name of the Amacalib MuDaq input file
+  void SetTWRDaqFile(TString name);   // Set name of the TWRDaq calibration input file
   void SetOutputFile(TString name);   // Set output file for the ROOT data structures           
   TDatabasePDG* GetPDG();             // Provide pointer to the PDG database
-  AliObjMatrix* GetOMdbase();         // Provide pointer to the OM geometry, calib. etc... database
+  AliObjMatrix* GetOMdbase(TString name="MuDaq"); // Provide pointer to the requested OM database
   virtual void Exec(Option_t* opt);   // Perform the format conversion
 
  protected :
   ifstream fInput;         // Input stream for generic use of reading data
 
-  TString fAmacalFileName; // Name of the Amacalib input file
-  TString fBadomFileName;  // Name of the bad OM input file
+  TString fAmacalFileName; // Name of the Amacalib MuDaq input file
+  TString fTWRDaqFileName; // Name of the TWRDaq calibration input file
   TString fRootFileName;   // Name of the ROOT output file
   TFile* fOutfile;         // The ROOT output file
 
   TDatabasePDG* fPdg;      // Database with PDG information
-  AliObjMatrix* fOmdb;     // Database of all OM devices with their geometry, calib. etc... data
+  AliObjMatrix* fMuDaqdb;  // Database of all OM devices with their MuDaq geometry, calib. etc... data
+  AliObjMatrix* fTWRDaqdb; // Database of all OM devices with their TWRDaq geometry, calib. etc... data
 
-  void GetCalibData();     // Fill geometry, calibration and Xtalk parameters of all devices
+  void GetMuDaqData();     // Fill MuDaq geometry, calibration and Xtalk parameters of all devices
+  void GetTWRDaqData();    // Fill TWRDaq geometry and calibration parameters of all devices
 
- ClassDef(IceCal2Root,1) // Job for conversion of Amacalib ascii data into an AliObjMatrix OM dbase
+ ClassDef(IceCal2Root,2) // Job for conversion of (ascii) calibration data into an AliObjMatrix OM dbase
 };
 #endif
index 39cda6b..bd075a2 100644 (file)
@@ -41,12 +41,10 @@ class IceRoot : public AliJob
   Int_t fPrintfreq;    // The event info printing frequency
   TObjArray* fInfiles; // Names of all the simple Root data input files
   TFile* fOutfile;     // The ROOT output file
-  void PutTrigger(Int_t year);   // Put the trigger info from the simple Root data event into the IcePack structure
-  void PutWaveforms(Int_t year); // Put the waveforms from the simple Root data event into the IcePack structure
 
   TFile* fInput;       // Simple Root data input file
   TTree* fTree;        // Tree with simple Root data
 
- ClassDef(IceRoot,1) // Job for conversion of simple Root data into IceEvent data structures.
+ ClassDef(IceRoot,2) // Job for conversion of simple Root data into IceEvent data structures.
 };
 #endif
index eb97f28..2e9394a 100644 (file)
                 separate histos in memberfunction PutWaveforms.
 15-mar-2007 GdV New class IceRoot introduced to convert I3 extracted ROOT trees
                 into IcePack event structures.
+30-mar-2007 GdV Obsolete memberfunction declarations PutTrigger and PutWaveforms removed
+                from IceRoot.h.
+01-jul-2007 NvE Class IceCal2Root extended to support various databases (e.g. MuDaq, TWRDaq, ...).
+
index 4a202b7..c9fffcb 100644 (file)
@@ -49,7 +49,13 @@ void Analyse::Exec(Option_t* opt)
 
  if (!parent) return;
 
- AliObjMatrix* omdb=(AliObjMatrix*)parent->GetMainObject();
+ TFolder* folder=parent->GetFolder();
+ if (!folder) return;
+
+ AliObjMatrix* omdb=0;
+ omdb=(AliObjMatrix*)folder->FindObject("MuDaq-OMDBASE");
+ // Next statement for compatibility with old calibration file format
+ if (!omdb) omdb=(AliObjMatrix*)folder->FindObject("Cal-OMDBASE");
  if (!omdb) return;
 
  IceAOM* omx=0;
index f42bdd3..9edb296 100644 (file)
@@ -30,5 +30,5 @@
  Analyse ana("Analyse","OMDB analyser");
  q.Add(&ana);
 
- q.ExecuteJob();
+ q.ExecuteJob(1);
 }
\ No newline at end of file