New TRDcalib directory
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Aug 2007 15:19:03 +0000 (15:19 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Aug 2007 15:19:03 +0000 (15:19 +0000)
TRD/TRDcalib/AliTRDcalib.cxx [new file with mode: 0644]
TRD/TRDcalib/AliTRDcalib.h [new file with mode: 0644]
TRD/TRDcalib/BUILD.sh [new file with mode: 0644]
TRD/TRDcalib/Makefile [new file with mode: 0644]
TRD/TRDcalib/Makefile.arch [new file with mode: 0644]
TRD/TRDcalib/SETUP.C [new file with mode: 0644]
TRD/TRDcalib/TRDcalibLinkDef.h [new file with mode: 0644]
TRD/TRDcalib/libTRDcalib.pkg2 [new file with mode: 0644]
TRD/TRDcalib/make_TRDcalib_par.sh [new file with mode: 0755]

diff --git a/TRD/TRDcalib/AliTRDcalib.cxx b/TRD/TRDcalib/AliTRDcalib.cxx
new file mode 100644 (file)
index 0000000..5f86b71
--- /dev/null
@@ -0,0 +1,359 @@
+#define AliTRDcalib_cxx
+// The class definition in Calib.h has been generated automatically
+// by the ROOT utility TTree::MakeSelector(). This class is derived
+// from the ROOT class TSelector. For more information on the TSelector
+// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.
+
+// The following methods are defined in this file:
+//    Begin():        called everytime a loop on the tree starts,
+//                    a convenient place to create your histograms.
+//    SlaveBegin():   called after Begin(), when on PROOF called only on the
+//                    slave servers.
+//    Process():      called for each event, in this function you decide what
+//                    to read and fill your histograms.
+//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
+//                    called only on the slave servers.
+//    Terminate():    called at the end of the loop on the tree,
+//                    a convenient place to draw/fit your histograms.
+//
+// To use this file, try the following session on your Tree T:
+//
+// Root > T->Process("AliTRDcalib.cxx")
+// Root > T->Process("AliTRDcalib.cxx","some options")
+// Root > T->Process("AliTRDcalib.cxx+")
+//
+
+#include "AliTRDcalib.h"
+#include <TTree.h>
+#include <TObject.h>
+#include <TH2.h>
+#include <TStyle.h>
+#include <TH2I.h>
+#include <TProfile2D.h>
+#include <TCanvas.h>
+#include <TStyle.h>
+
+#include <AliESDEvent.h>
+#include <AliESDfriend.h> 
+#include <AliESDtrack.h>
+#include <AliESDfriendTrack.h>
+
+#include <AliTRDgeometry.h>
+#include <AliTRDtrack.h>
+#include <AliTRDcluster.h>
+#include <AliCDBManager.h>
+#include <AliTRDCalibraFillHisto.h>
+#include <AliTRDCalibraVdriftLinearFit.h>
+
+
+AliTRDcalib::AliTRDcalib(TTree *) : 
+   TSelector(),
+   fev(0),
+   fevf(0),
+   fo(0),
+   ft(0),
+   fc(0),
+   fesdTrack(0),
+   ffriendTrack(0),
+   fFileNo(0)     
+ {
+   //G__SetCatchException(0);     
+ }  
+//_____________________________________________________________________
+void AliTRDcalib::Begin(TTree * /*tree*/)
+{
+   // The Begin() function is called at the start of the query.
+   // When running with PROOF Begin() is only called on the client.
+   // The tree argument is deprecated (on PROOF 0 is passed).
+
+   //TString option = GetOption();
+  
+}
+//______________________________________________________________________
+void AliTRDcalib::SlaveBegin(TTree * tree)
+{
+   // The SlaveBegin() function is called after the Begin() function.
+   // When running with PROOF SlaveBegin() is called on each slave server.
+   // The tree argument is deprecated (on PROOF 0 is passed).
+
+  //printf("Slave Begin\n");
+
+   //TString option = GetOption();
+  if(tree) Init(tree);
+
+  fo = 0x0;
+  ft = 0x0;
+  fc = 0x0;
+  fesdTrack = 0x0;
+  ffriendTrack = 0x0;
+
+  AliCDBManager *cdbManager = AliCDBManager::Instance();
+  cdbManager->SetDefaultStorage("local://$ALICE_ROOT");
+  //cdbManager->SetSpecificStorage("TRD/Calib/FEE","local:///u/bailhach/aliroot/database30head/");
+  cdbManager->SetRun(0);
+
+  // instance calibration
+  fcalib = AliTRDCalibraFillHisto::Instance();
+  fcalib->SetNz(0,0);
+  fcalib->SetNrphi(0,0);
+  fcalib->SetNz(1,0);
+  fcalib->SetNrphi(1,0);
+  fcalib->SetMITracking();
+  fcalib->SetHisto2d();
+  fcalib->SetVector2d();
+  fcalib->SetLinearFitterOn();
+  fcalib->SetLinearFitterDebugOn();
+  fcalib->SetCH2dOn();
+  fcalib->SetPH2dOn();
+  fcalib->SetPRF2dOn();
+  fcalib->Init2Dhistostrack();
+  //fcalib->SetDebugLevel(1);
+  fcalib->SetNumberClusters(14);
+
+}
+//__________________________________________________________________________
+void   AliTRDcalib::CleanESD(){
+  //
+  //printf("CleanESD\n");
+  if (fev!=0){
+    delete fev;
+    fev = 0;
+  }
+  if (fevf!=0){
+    delete fevf;
+    fevf =0;
+  }
+}
+//_________________________________________________________________________________
+Bool_t AliTRDcalib::Process(Long64_t entry)
+{
+   // The Process() function is called for each entry in the tree (or possibly
+   // keyed object in the case of PROOF) to be processed. The entry argument
+   // specifies which entry in the currently loaded tree is to be processed.
+   // It can be passed to either Calib::GetEntry() or TBranch::GetEntry()
+   // to read either all or the required parts of the data. When processing
+   // keyed objects with PROOF, the object is already loaded and is available
+   // via the fObject pointer.
+   //
+   // This function should contain the "body" of the analysis. It can contain
+   // simple or elaborate selection criteria, run algorithms on the data
+   // of the event and typically fill histograms.
+   //
+   // The processing can be stopped by calling Abort().
+   //
+   // Use fStatus to set the return value of TTree::Process().
+   //
+   // The return value is currently not used.
+  //printf("process\n");
+  if (!fChain) return kFALSE;  
+  //printf("process1\n");
+  Int_t nBytes;
+  Int_t nTRDcls = 0;
+  nBytes = fChain->GetTree()->GetEntry(entry);
+  //printf("There are %d bytes for these event\n",nBytes);
+  if (!fev || (nBytes == 0)) { 
+    return kFALSE;
+  }
+  if(fev->GetAliESDOld()) fev->CopyFromOldESD();
+  //printf("process2\n");
+  Int_t ntr = fev->GetNumberOfTracks();
+  //printf("Tracks new %d\n",ntr);
+  
+  if (!fevf || (fevf->GetNumberOfTracks()!=ntr)) {
+    return kFALSE;
+  }
+  
+  if(ntr>0){
+    
+    fev->SetESDfriend(fevf);
+    
+    //printf("Number of friends tracks %d\n",fevf->GetNumberOfTracks());
+    
+    
+    for(int itrk=0; itrk<fev->GetNumberOfTracks(); itrk++){
+     
+      fesdTrack = fev->GetTrack(itrk);
+      if(!(nTRDcls = fesdTrack->GetTRDncls())) continue;
+      if(!(fesdTrack->GetFriendTrack())) continue;
+      ffriendTrack = new AliESDfriendTrack(*(fesdTrack->GetFriendTrack()));
+                 
+      Int_t icalib=0;
+      while((fo = (TObject *)(ffriendTrack->GetCalibObject(icalib++)))){
+       //printf("Name of calibObject %s\n",fo->IsA()->GetName());
+       if(strcmp(fo->IsA()->GetName(), "AliTRDtrack") != 0) continue;
+       //printf("\tfound %s @ 0x%x; calib object %d\n", fo->IsA()->GetName(), fo, icalib-1);
+       ft = (AliTRDtrack *)fo;
+       
+       fcalib->UpdateHistograms(ft);
+      }
+    }
+  }
+  
+  //CleanESD();
+  return kTRUE;
+}
+//______________________________________________________________________________________________
+void AliTRDcalib::SlaveTerminate()
+{
+   // The SlaveTerminate() function is called after all entries or objects
+   // have been processed. When running with PROOF SlaveTerminate() is called
+   // on each slave server.
+
+  if(!fOutput)
+    {
+      printf("ERROR: Output list not initialized\n");
+      return;
+    }
+  
+  fCH2d = new TH2I(*(fcalib->GetCH2d()));
+  fPH2d = new TProfile2D(*(fcalib->GetPH2d()));
+  fPRF2d = new TProfile2D(*(fcalib->GetPRF2d()));
+
+  AliTRDCalibraVdriftLinearFit *ju = fcalib->GetVdriftLinearFit();
+  for(Int_t det = 0; det < 540; det++){
+    fVdriftLinear[det] = new TH2F(*(ju->GetLinearFitterHisto(det,kTRUE)));
+  }
+  
+
+
+  fOutput->Add(fCH2d);
+  fOutput->Add(fPH2d);
+  fOutput->Add(fPRF2d);
+  for(Int_t det = 0; det < 540; det++){
+    fOutput->Add(fVdriftLinear[det]);
+  }
+
+  fcalib->Destroy();
+}
+//____________________________________________________________________________________
+void AliTRDcalib::Terminate()
+{
+   // 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.
+
+  printf("InTerminate()\n");
+  if (!fOutput) return;
+  //fOutput->Print();
+  
+  fCH2d = dynamic_cast<TH2I*>(fOutput->FindObject("CH2d"));
+  
+  if (!fCH2d)
+    {
+      printf("Error: %s not returned\n","fCH2d");
+      return;
+    }
+
+  fPH2d = dynamic_cast<TProfile2D*>(fOutput->FindObject("PH2d"));
+  
+  if (!fPH2d)
+    {
+      printf("Error: %s not returned\n","fPH2d");
+      return;
+    }
+
+  fPRF2d = dynamic_cast<TProfile2D*>(fOutput->FindObject("PRF2d"));
+  
+  if (!fPRF2d)
+    {
+      printf("Error: %s not returned\n","fPRF2d");
+      return;
+    }
+
+
+  const char * Name = 0x0;
+  Name = "LFDV%dversion0";
+  TObjArray array(540);
+
+  for(Int_t det = 0; det < 540; det++){
+
+    TString Namehisto (Form(Name, det));
+    fVdriftLinear[det] = dynamic_cast<TH2F*>(fOutput->FindObject((const char *)Namehisto));
+    if (!fVdriftLinear[det])
+      {
+       printf("Error: %s not returned\n",(const char *)Namehisto);
+       return;
+      }
+    array.AddAt(fVdriftLinear[det],det);
+  }
+
+  AliTRDCalibraVdriftLinearFit vdriftlinearfit = AliTRDCalibraVdriftLinearFit(array);
+  vdriftlinearfit.FillPEArray();
+
+  gStyle->SetPalette(1);
+  gStyle->SetOptStat(1111);
+  gStyle->SetPadBorderMode(0);
+  gStyle->SetCanvasColor(10);
+  gStyle->SetPadLeftMargin(0.13);
+  gStyle->SetPadRightMargin(0.10);
+
+  printf("There are %d files analysed\n",fFileNo);
+  
+  
+  TCanvas *u = new TCanvas("u","",50,50,600,800);
+  u->Divide(3,1);
+  u->cd(1);
+  fCH2d->DrawCopy("lego");
+  u->cd(2);
+  fPH2d->DrawCopy("lego");
+  u->cd(3);
+  fPRF2d->DrawCopy("lego");
+
+  TObjArray *arrayE = vdriftlinearfit.GetEArray();
+
+  Double_t totalsum = 0.0;
+  for(Int_t k = 0; k < 540; k++){
+    TVectorD *h = (TVectorD *) arrayE->UncheckedAt(k);
+    if(h){
+      totalsum += (*h)[2];
+    }
+  }
+
+  TFile file("Output.root","recreate");
+  fOutput->Write();  
+
+}
+//___________________________________________________________________________________________
+void AliTRDcalib::Init(TTree *tree)
+{
+   // The Init() function is called when the selector needs to initialize
+   // a new tree or chain. Typically here the branch addresses and branch
+   // pointers of the tree will be set.
+   // It is normaly not necessary to make changes to the generated
+   // code, but the routine can be extended by the user if needed.
+   // Init() will be called many times when running on PROOF
+   // (once per file to be processed).
+
+   // Set branch addresses and branch pointers
+   if (!tree) return;
+   fChain = tree;
+   fev = new AliESDEvent();
+   fChain->SetBranchStatus("ESDfriend*",1);
+   fev->ReadFromTree(fChain);
+   fevf = 0x0;
+   fevf = (AliESDfriend*)fev->FindListObject("AliESDfriend");
+   if(!fevf){
+     fChain->SetBranchAddress("ESDfriend.",&fevf);
+   }
+   
+
+}
+//___________________________________________________________________________________________
+Bool_t AliTRDcalib::Notify()
+{
+   // The Notify() function is called when a new file is opened. This
+   // can be either for a new TTree in a TChain or when when a new TTree
+   // is started when using PROOF. It is normaly not necessary to make changes
+   // to the generated code, but the routine can be extended by the
+   // user if needed. The return value is currently not used.
+
+  ++fFileNo;
+  printf ("Processing file no %d\n",fFileNo);
+  
+  return kTRUE;
+}
diff --git a/TRD/TRDcalib/AliTRDcalib.h b/TRD/TRDcalib/AliTRDcalib.h
new file mode 100644 (file)
index 0000000..9ffac05
--- /dev/null
@@ -0,0 +1,80 @@
+//////////////////////////////////////////////////////////
+// This class has been automatically generated on
+// Fri Jul 27 15:22:59 2007 by ROOT version 5.16/00
+// from TTree esdTree/Tree with ESD objects
+// found on file: AliESDs.root
+//////////////////////////////////////////////////////////
+
+#ifndef AliTRDcalib_h
+#define AliTRDcalib_h
+
+#include <TROOT.h>
+#include <TH2I.h>
+#include <TH2F.h>
+#include <TProfile2D.h>
+#include <TProfile.h>
+#include <TChain.h>
+#include <TTree.h>
+#include <TFile.h>
+#include <TSelector.h>
+#include <TObject.h>
+
+
+class AliESDEvent;
+class AliESDfriend;
+class AliESDtrack;
+class AliESDfriendTrack;
+
+class AliTRDCalibraFillHisto;
+class AliTRDtrack;
+class AliTRDcluster;
+
+
+class AliTRDcalib : public TSelector {
+public :
+  TTree          *fChain;   //!pointer to the analyzed TTree or TChain
+
+  //variables
+  AliESDEvent *fev;
+  AliESDfriend *fevf;
+  TObject *fo;
+  AliTRDtrack *ft;
+  AliTRDcluster *fc;
+  const AliESDtrack *fesdTrack;
+  AliESDfriendTrack *ffriendTrack;
+
+  //calibration class
+  AliTRDCalibraFillHisto *fcalib;
+
+  //Store infos
+  TH2I *fCH2d;
+  TProfile2D *fPH2d;
+  TProfile2D *fPRF2d;
+  TH2F     *fVdriftLinear[540];
+
+
+
+  // For the case no proof
+  Int_t    fFileNo;
+
+  AliTRDcalib(TTree *tree=0);
+  virtual ~AliTRDcalib() { }
+  virtual Int_t   Version() const { return 2; }
+  virtual void    Begin(TTree *tree);
+  virtual void    SlaveBegin(TTree *tree);
+  virtual void    Init(TTree *tree);
+  virtual Bool_t  Notify();
+  virtual Bool_t  Process(Long64_t entry);
+  virtual Int_t   GetEntry(Long64_t entry, Int_t getall = 0) { return fChain ? fChain->GetTree()->GetEntry(entry, getall) : 0; }
+  virtual void    SetOption(const char *option) { fOption = option; }
+  virtual void    SetObject(TObject *obj) { fObject = obj; }
+  virtual void    SetInputList(TList *input) { fInput = input; }
+  virtual TList  *GetOutputList() const { return fOutput; }
+  virtual void    SlaveTerminate();
+  virtual void    Terminate();
+  void            CleanESD();
+
+   ClassDef(AliTRDcalib,0);
+};
+
+#endif
diff --git a/TRD/TRDcalib/BUILD.sh b/TRD/TRDcalib/BUILD.sh
new file mode 100644 (file)
index 0000000..fc9490a
--- /dev/null
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+make 
diff --git a/TRD/TRDcalib/Makefile b/TRD/TRDcalib/Makefile
new file mode 100644 (file)
index 0000000..a2031ee
--- /dev/null
@@ -0,0 +1,33 @@
+PACKAGE = TRDcalib
+
+include Makefile.arch
+include lib$(PACKAGE).pkg2
+
+ifndef PACKCXXFLAGS
+PACKCXXFLAGS = $(CXXFLAGS)
+endif
+
+SRCS         += G__$(PACKAGE).cxx
+OBJS          = $(SRCS:.cxx=.o)
+
+lib$(PACKAGE).so: $(OBJS)
+       @echo "Linking" $@ ...
+       @/bin/rm -f $@
+ifeq ($(PLATFORM),macosx)
+       @$(LD) -bundle -undefined $(UNDEFOPT) $(LDFLAGS) $^ -o $@
+else
+       @$(LD) $(SOFLAGS) $(LDFLAGS) $^ -o $@
+endif
+       @chmod a+x $@
+       @echo "done"
+
+%.o:    %.cxx %.h
+       $(CXX) $(PACKCXXFLAGS) -I$(ALICE_ROOT)/include -I$(ALICE_ROOT)/TRD  -I$(ALICE_ROOT)/STEER -c $< -o $@
+
+clean:
+       @rm -f $(OBJS) *.so G__$(PACKAGE).*
+
+G__$(PACKAGE).cxx G__$(PACKAGE).h: $(HDRS) $(DHDR)
+       @echo "Generating dictionary ..."
+       rootcint  -f $@ -c $(CINTFLAGS) $(ALICEINC) $^
+
diff --git a/TRD/TRDcalib/Makefile.arch b/TRD/TRDcalib/Makefile.arch
new file mode 100644 (file)
index 0000000..048e324
--- /dev/null
@@ -0,0 +1,516 @@
+# -*- mode: makefile -*-
+#
+# Makefile containing platform dependencies for ROOT based projects.
+#
+# Copyright (c) 2000 Rene Brun and Fons Rademakers
+#
+# Author: Fons Rademakers, 29/2/2000
+
+ROOTCONFIG   := root-config
+
+ARCH         := $(shell $(ROOTCONFIG) --arch)
+PLATFORM     := $(shell $(ROOTCONFIG) --platform)
+
+CXX           =
+ObjSuf        = o
+SrcSuf        = cxx
+ExeSuf        =
+DllSuf        = so
+OutPutOpt     = -o # keep whitespace after "-o"
+
+ifeq (debug,$(findstring debug,$(ROOTBUILD)))
+OPT           = -g
+OPT2          = -g
+else
+ifneq ($(findstring debug, $(strip $(shell $(ROOTCONFIG) --config))),)
+OPT           = -g
+OPT2          = -g
+else
+OPT           = -O
+OPT2          = -O2
+endif
+endif
+
+ROOTCFLAGS   := $(shell $(ROOTCONFIG) --cflags)
+ROOTLDFLAGS  := $(shell $(ROOTCONFIG) --ldflags)
+ROOTLIBS     := $(shell $(ROOTCONFIG) --libs)
+ROOTGLIBS    := $(shell $(ROOTCONFIG) --glibs)
+HASTHREAD    := $(shell $(ROOTCONFIG) --has-thread)
+
+ifeq ($(ARCH),hpuxacc)
+# HP-UX 10.x with aCC
+CXX           = aCC
+CXXFLAGS      = $(OPT) +Z
+LD            = aCC
+LDFLAGS       = $(OPT) -z
+SOFLAGS       = -b
+endif
+
+ifeq ($(ARCH),hpuxia64acc)
+# HP-UX 11i 1.5 (IA-64) with aCC
+CXX           = aCC
+CXXFLAGS      = +DD64 $(OPT) +Z
+LD            = aCC
+LDFLAGS       = +DD64 $(OPT) -z
+SOFLAGS       = -b
+endif
+
+ifeq ($(ARCH),hpuxgcc)
+# HP-UX 10.x with g++
+CXXFLAGS      = $(OPT) -fPIC
+CXX           = g++
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -fPIC -shared
+endif
+
+ifeq ($(ARCH),hurddeb)
+# GNU/Hurd
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),aix)
+# IBM AIX xlC 4.x
+CXX           = xlC
+CXXFLAGS      = $(OPT)
+LD            = xlC
+LDFLAGS       = $(OPT)
+SOFLAGS       =
+DllSuf        = a
+endif
+
+ifeq ($(ARCH),aix5)
+# IBM AIX xlC 5.x
+CXX           = xlC
+CXXFLAGS      = $(OPT)
+LD            = xlC
+LDFLAGS       = $(OPT)
+SOFLAGS       =
+DllSuf        = a
+endif
+
+ifeq ($(ARCH),aixgcc)
+# IBM AIX with GCC
+CXX           = g++
+CXXFLAGS      = $(OPT)
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+DllSuf        = a
+EXPLLINKLIBS  = $(ROOTLIBS) $(ROOTGLIBS)
+endif
+
+ifeq ($(ARCH),solaris)
+# Solaris CC
+CXX           = /opt/SUNWspro/bin/CC
+CXXFLAGS      = $(OPT) -KPIC
+LD            = /opt/SUNWspro/bin/CC
+LDFLAGS       = $(OPT)
+SOFLAGS       = -G
+endif
+
+ifeq ($(ARCH),solarisCC5)
+# Solaris CC 5.0
+CXX           = CC
+CXXFLAGS      = $(OPT) -KPIC
+LD            = CC
+LDFLAGS       = $(OPT)
+SOFLAGS       = -G
+endif
+
+ifeq ($(ARCH),solarisgcc)
+# Solaris gcc
+CXX           = g++
+CXXFLAGS      = $(OPT) -fPIC
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),solariskcc)
+# Solaris kcc
+CXX           = KCC --one_instantiation_per_object
+CXXFLAGS      = -O4 -KPIC
+LD            = KCC
+LDFLAGS       = -O4
+SOFLAGS       =
+endif
+
+ifeq ($(ARCH),solarisx86)
+# Solaris CC on Intel
+CXX           = CC
+CXXFLAGS      = $(OPT) -KPIC
+LD            = CC
+LDFLAGS       = $(OPT)
+SOFLAGS       = -G
+endif
+
+ifeq ($(ARCH),sgicc)
+# SGI
+CXX           = CC -n32  -I/usr/include/CC.sgi
+CXXFLAGS      = $(OPT)
+LD            = CC -n32 -LANG:std  -I/usr/include/CC.sgi
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),sgicc64)
+# SGI
+CXX           = CC -64  -I/usr/include/CC.sgi
+CXXFLAGS      = $(OPT)
+LD            = CC -64 -LANG:std -I/usr/include/CC.sgi
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),sgigcc)
+# SGI 6.x with gcc
+CXX           = g++
+CXXFLAGS      = $(OPT) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT) -Wl,-u,__builtin_new -Wl,-u,__builtin_delete -Wl,-u,__nw__FUiPv
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),sgin32gcc)
+# SGI 6.x with gcc for n32 ABI
+CXX           = g++
+CXXFLAGS      = $(OPT) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT) -L/usr/lib32 -Wl,-woff,134 -lgen
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),sgikcc)
+# SGI with KCC
+CXX           = KCC -n32 --one_instantiation_per_object
+CXXFLAGS      = $(OPT)
+LD            = KCC -n32
+LDFLAGS       = $(OPT)
+SOFLAGS       =
+endif
+
+ifeq ($(ARCH),alphagcc)
+# Alpha/OSF with gcc
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -Wl,-expect_unresolved,* -shared
+endif
+
+ifeq ($(ARCH),alphakcc)
+# Alpha/OSF with kai compiler (not yet valid)
+CXX           = KCC --one_instantiation_per_object
+CXXFLAGS      = $(OPT) -fPIC
+LD            = KCC
+LDFLAGS       = $(OPT)
+SOFLAGS       = -Wl,-expect_unresolved,* -shared
+endif
+
+ifeq ($(ARCH),alphacxx6)
+# Alpha/OSF with cxx6
+CXX           = cxx
+CXXFLAGS      = $(OPT)
+LD            = cxx
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared -nocxxstd -Wl,-expect_unresolved,*,-msym
+endif
+
+ifeq ($(ARCH),linuxdeb2ppc)
+# Debian/Linux on the PowerPC
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linux)
+# Linux with egcs, gcc 2.9x, gcc 3.x
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxkcc)
+# Linux with the KAI compiler
+CXX           = KCC --one_instantiation_per_object
+CXXFLAGS      = $(OPT) -fPIC +K0
+LD            = KCC
+LDFLAGS       = $(OPT) $(shell $(ROOTCONFIG) --cflags)
+SOFLAGS       =
+endif
+
+ifeq ($(ARCH),linuxicc)
+# Linux with Intel icc compiler
+ICC_MAJOR    := $(shell icc -v 2>&1 | awk '{ if (NR==1) print $$2 }' | \
+                cut -d'.' -f1)
+ICC_MINOR    := $(shell icc -v 2>&1 | awk '{ if (NR==1) print $$2 }' | \
+                cut -d'.' -f2)
+CXX           = icc
+CXXFLAGS      = $(OPT) -fPIC -wd1476
+LD            = icpc
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxppcgcc)
+# PPC Linux with gcc and glibc
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxia64gcc)
+# Itanium Linux with gcc 2.9x
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxia64sgi)
+# Itanium Linux with sgiCC
+CXX           = sgiCC
+CXXFLAGS      = $(OPT) -Wall -fPIC
+LD            = gsgiCC
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxia64ecc)
+# Itanium Linux with Intel icc (was ecc)
+ICC_MAJOR    := $(shell icc -v 2>&1 | awk '{ if (NR==1) print $$2 }' | \
+                cut -d'.' -f1)
+ICC_MINOR    := $(shell icc -v 2>&1 | awk '{ if (NR==1) print $$2 }' | \
+                cut -d'.' -f2)
+CXX           = icc
+CXXFLAGS      = $(OPT) -fPIC -wd1476
+LD            = icpc
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxx8664gcc)
+# AMD Opteron and Intel EM64T (64 bit mode) Linux with gcc 3.x
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxppc64gcc)
+# PPC64 Linux with gcc 3.x
+CXX           = g++
+CXXFLAGS      = $(OPT) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxx8664icc)
+# AMD Opteron and Intel EM64T (64 bit mode) Linux with Intel icc compiler
+CXX           = icc
+CXXFLAGS      = $(OPT) -fPIC -wd1476 -wd1572
+LD            = icpc
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxalphagcc)
+# Alpha Linux with gcc
+CXX           = g++
+CXXFLAGS      = $(OPT2) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT2)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),linuxarm)
+# ARM Linux with egcs
+CXX           = g++
+CXXFLAGS      = $(OPT) -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared
+endif
+
+ifeq ($(ARCH),freebsd4)
+# FreeBSD with glibc
+CXX           = g++
+CXXFLAGS      = $(OPT) -W -Wall -fPIC
+LD            = $(CXX)
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared -Wl,-x
+endif
+
+ifeq ($(ARCH),freebsd5)
+# FreeBSD with glibc
+CXX           = g++
+CXXFLAGS      = $(OPT) -W -Wall -fPIC
+LD            = $(CXX)
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared -Wl,-x
+endif
+
+ifeq ($(ARCH),openbsd)
+# OpenBSD with libc
+CXX           = g++
+CXXFLAGS      = $(OPT) -pipe -W -Wall -fPIC
+LD            = g++
+LDFLAGS       = $(OPT)
+SOFLAGS       = -shared -Wl,-x
+endif
+
+ifeq ($(ARCH),macosx)
+# MacOS X with cc (GNU cc 2.95.2 and gcc 3.3)
+MACOSX_MINOR := $(shell sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2)
+MACOSXTARGET := MACOSX_DEPLOYMENT_TARGET=10.$(MACOSX_MINOR)
+ifeq ($(MACOSX_MINOR),5)
+MACOSX_MINOR  = 4
+endif
+CXX           = c++
+CXXFLAGS      = $(OPT2) -pipe -Wall -W -Woverloaded-virtual
+LD            = $(MACOSXTARGET) c++
+LDFLAGS       = $(OPT2) -bind_at_load
+# The SOFLAGS will be used to create the .dylib,
+# the .so will be created separately
+DllSuf        = dylib
+UNDEFOPT      = dynamic_lookup
+ifneq ($(MACOSX_MINOR),4)
+ifneq ($(MACOSX_MINOR),3)
+UNDEFOPT      = suppress
+LD            = c++
+endif
+endif
+SOFLAGS       = -dynamiclib -single_module -undefined $(UNDEFOPT)
+endif
+
+ifeq ($(ARCH),macosxicc)
+# MacOS X with Intel icc compiler
+MACOSX_MINOR := $(shell sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2)
+MACOSXTARGET := MACOSX_DEPLOYMENT_TARGET=10.$(MACOSX_MINOR)
+ifeq ($(MACOSX_MINOR),5)
+MACOSX_MINOR  = 4
+endif
+CXX           = icc
+CXXFLAGS      = $(OPT) -fPIC -wd1476
+LD            = $(MACOSXTARGET) icpc
+LDFLAGS       = $(OPT)
+# The SOFLAGS will be used to create the .dylib,
+# the .so will be created separately
+DllSuf        = dylib
+SOFLAGS       = -dynamiclib -single_module -undefined dynamic_lookup
+endif
+
+ifeq ($(ARCH),macosx64)
+# MacOS X >= 10.4 with gcc 64 bit mode (GNU gcc 4.*)
+# Only specific option (-m64) comes from root-config
+MACOSX_MINOR := $(shell sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2)
+MACOSXTARGET := MACOSX_DEPLOYMENT_TARGET=10.$(MACOSX_MINOR)
+ifeq ($(MACOSX_MINOR),5)
+MACOSX_MINOR  = 4
+endif
+CXX           = c++
+CXXFLAGS      = $(OPT2) -pipe -Wall -W -Woverloaded-virtual
+LD            = $(MACOSXTARGET) c++ -m64
+LDFLAGS       = $(OPT2) -bind_at_load
+# The SOFLAGS will be used to create the .dylib,
+# the .so will be created separately
+DllSuf        = dylib
+SOFLAGS       = -m64 -dynamiclib -single_module -undefined dynamic_lookup
+endif
+
+ifeq ($(ARCH),macosxxlc)
+# MacOS X with IBM xlC compiler
+MACOSX_MINOR := $(shell sw_vers | sed -n 's/ProductVersion://p' | cut -d . -f 2)
+MACOSXTARGET := MACOSX_DEPLOYMENT_TARGET=10.$(MACOSX_MINOR)
+ifeq ($(MACOSX_MINOR),5)
+MACOSX_MINOR  = 4
+endif
+CXX           = xlC
+CXXFLAGS      = $(OPT)
+LD            = $(MACOSXTARGET) xlC
+LDFLAGS       = $(OPT) -Wl,-bind_at_load
+# The SOFLAGS will be used to create the .dylib,
+# the .so will be created separately
+DllSuf        = dylib
+UNDEFOPT      = dynamic_lookup
+ifneq ($(MACOSX_MINOR),4)
+ifneq ($(MACOSX_MINOR),3)
+UNDEFOPT      = suppress
+LD            = xlC
+endif
+endif
+SOFLAGS       = -qmkshrobj -single_module -undefined $(UNDEFOPT)
+endif
+
+ifeq ($(ARCH),win32)
+# Windows with the VC++ compiler
+VC_MAJOR     := $(shell unset VS_UNICODE_OUTPUT; cl.exe 2>&1 | awk '{ if (NR==1) print $$8 }' | \
+                cut -d'.' -f1)
+ObjSuf        = obj
+SrcSuf        = cxx
+ExeSuf        = .exe
+DllSuf        = dll
+OutPutOpt     = -out:
+CXX           = cl
+ifeq (debug,$(findstring debug,$(ROOTBUILD)))
+CXXOPT        = -Z7
+LDOPT         = -debug
+else
+ifneq ($(findstring debug, $(strip $(shell $(ROOTCONFIG) --config))),)
+CXXOPT        = -Z7
+LDOPT         = -debug
+else
+CXXOPT        = -O2
+LDOPT         = -opt:ref
+endif
+endif
+CXXFLAGS      = $(CXXOPT) -nologo -I$(shell $(ROOTCONFIG) --incdir) -FIw32pragma.h
+LD            = link
+LDFLAGS       = $(LDOPT) -nologo
+SOFLAGS       = -DLL
+
+EXPLLINKLIBS  = $(ROOTLIBS) $(ROOTGLIBS)
+ifeq ($(VC_MAJOR),14)
+MT_EXE        = mt -nologo -manifest $@.manifest -outputresource:$@\;1; rm -f $@.manifest
+MT_DLL        = mt -nologo -manifest $@.manifest -outputresource:$@\;2; rm -f $@.manifest
+else
+MT_EXE        =
+MT_DLL        =
+endif
+endif
+
+ifeq ($(ARCH),win32gcc)
+# Windows with gcc
+DllSuf        = dll
+ExeSuf        = .exe
+CXX           = g++
+CXXFLAGS      = $(OPT) -pipe -Wall -Woverloaded-virtual -I/usr/X11R6/include
+LD            = g++
+LDFLAGS       = $(OPT) -Wl,--enable-auto-import -Wl,--enable-runtime-pseudo-reloc \
+               -L/usr/X11R6/lib
+SOFLAGS       = -shared -D_DLL -Wl,--export-all-symbols
+EXPLLINKLIBS  = $(ROOTLIBS) $(ROOTGLIBS)
+endif
+
+ifeq ($(CXX),)
+$(error $(ARCH) invalid architecture)
+endif
+
+CXXFLAGS     += $(ROOTCFLAGS)
+LDFLAGS      += $(ROOTLDFLAGS)
+LIBS          = $(ROOTLIBS) $(SYSLIBS)
+GLIBS         = $(ROOTGLIBS) $(SYSLIBS)
diff --git a/TRD/TRDcalib/SETUP.C b/TRD/TRDcalib/SETUP.C
new file mode 100644 (file)
index 0000000..4329b4d
--- /dev/null
@@ -0,0 +1,15 @@
+void SETUP()
+{
+  
+  // load all libraries
+  //gProof->Exec("gROOT->Macro(\"$ALICE_ROOT/macros/loadlibsREC.C\")");
+   // Load the ESD library
+   gSystem->Load("libTRDcalib");
+
+   // Set the Inlucde paths
+   //gSystem->SetIncludePath("-I$ROOTSYS/include -ITPCcalib");
+   //gROOT->ProcessLine(".include TPCcalib");
+
+   // Set our location, so that other packages can find us
+   //gSystem->Setenv("TPCcalib_INCLUDE", "TPCcalib");
+}
diff --git a/TRD/TRDcalib/TRDcalibLinkDef.h b/TRD/TRDcalib/TRDcalibLinkDef.h
new file mode 100644 (file)
index 0000000..1002658
--- /dev/null
@@ -0,0 +1,20 @@
+#ifdef __CINT__
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+
+#pragma link C++ class  AliTRDcalib+;
+
+#endif
+
+
+
+
+
diff --git a/TRD/TRDcalib/libTRDcalib.pkg2 b/TRD/TRDcalib/libTRDcalib.pkg2
new file mode 100644 (file)
index 0000000..b70af10
--- /dev/null
@@ -0,0 +1,12 @@
+SRCS = AliTRDcalib.cxx
+       
+
+HDRS:= $(SRCS:.cxx=.h) 
+
+EINCLUDE:=RAW TRD STEER
+
+DHDR= TRDcalibLinkDef.h
+
+EXPORT:=$(SRCS:.cxx=.h)
+
+
diff --git a/TRD/TRDcalib/make_TRDcalib_par.sh b/TRD/TRDcalib/make_TRDcalib_par.sh
new file mode 100755 (executable)
index 0000000..5eeba1f
--- /dev/null
@@ -0,0 +1,46 @@
+#! /bin/sh
+#
+# Make the event.par file to be used to analyse Event objects with PROOF.
+#
+# Usage: sh make_event_par.sh
+#
+# Creates the PAR file "event.par" which can be used in PROOF via the
+# package manager like:
+#   gProof->UploadPackage("event.par")
+#   gProof->EnablePackage("event")
+#
+# Command to check that package is active and that libEvent.so is loaded:
+#   gProof->ShowPackages()
+#   gProof->ShowEnabledPackages()
+#   gProof->Exec("gSystem->ListLibraries()")
+#
+
+EDIR=TRDcalib
+
+mkdir $EDIR
+
+
+SRC=$ALICE_ROOT/TRD/TRDcalib
+echo Source $SRC  
+echo EDIR $EDIR
+
+cp $SRC/Ali*.h                $EDIR
+cp $SRC/Ali*.cxx              $EDIR
+cp $SRC/TRDcalibLinkDef.h     $EDIR
+cp $SRC/Makefile*             $EDIR
+cp $SRC/libTRDcalib.pkg2      $EDIR  
+
+mkdir $EDIR/PROOF-INF
+cd $EDIR/PROOF-INF
+
+
+cp $SRC/BUILD.sh .
+cp $SRC/SETUP.C  .
+
+
+chmod 755 BUILD.sh
+
+cd ../..
+
+tar zcvf TRDcalib.par $EDIR
+