Follow AliAlignObj framework and remove AliPHOSAlignData (Yu.Kharlov)

diff --git a/PHOS/AliPHOS.cxx b/PHOS/AliPHOS.cxx
index 01bbdca7176cee51ffa6fc5545cc2161e5b2f095..661308d301b129cd41786d00cbdb9616ffa24268 100644 (file)
--- a/PHOS/AliPHOS.cxx
+++ b/PHOS/AliPHOS.cxx
@@ -16,6 +16,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.95  2006/03/14 19:40:41  kharlov
+ * Remove De-digitizing of raw data and digitizing the raw data fit
+ *
  * Revision 1.94  2006/03/07 18:56:25  kharlov
  * CDB is passed via environment variable
  *
@@ -94,25 +97,10 @@ AliPHOS::AliPHOS(const char* name, const char* title): AliDetector(name, title)
 {
   //   ctor : title is used to identify the layout
 
-  // Check if CDB_PATH is defined and take alignment data from CDB
-  AliPHOSAlignData* alignda = 0;
-  if (gSystem->Getenv("CDB_PATH")) {
-    TString cdbPath = gSystem->Getenv("CDB_PATH");
-    AliCDBStorage *cdbStorage = AliCDBManager::Instance()->GetStorage(cdbPath);
-    if (cdbStorage != NULL) {
-      alignda  =
-       (AliPHOSAlignData*)(cdbStorage->Get("PHOS/Alignment/Geometry",0)->GetObject());
-      if(AliLog::GetGlobalDebugLevel()>0) alignda->Print();
-    }
-    else {
-      Fatal("AliPHOS", "No CDB storage at the path %s", cdbPath.Data()) ;
-    }
-  }
-  
   fHighCharge        = 8.2 ;          // adjusted for a high gain range of 5.12 GeV (10 bits)
   fHighGain          = 6.64 ; 
   fHighLowGainFactor = 16. ;          // adjusted for a low gain range of 82 GeV (10 bits) 
-  fLowGainOffset     = GetGeometry(alignda)->GetNModules() + 1 ;   
+  fLowGainOffset     = GetGeometry()->GetNModules() + 1 ;   
     // offset added to the module id to distinguish high and low gain data
 }
 
@@ -438,7 +426,7 @@ void AliPHOS::Digits2Raw()
 
   // get the digitizer 
   loader->LoadDigitizer();
-//   AliPHOSDigitizer * digitizer = dynamic_cast<AliPHOSDigitizer *>(loader->Digitizer())  ; 
+  AliPHOSDigitizer * digitizer = dynamic_cast<AliPHOSDigitizer *>(loader->Digitizer())  ; 
   
   // get the geometry
   AliPHOSGeometry* geom = GetGeometry();
@@ -456,15 +444,6 @@ void AliPHOS::Digits2Raw()
   Int_t adcValuesLow[fkTimeBins];
   Int_t adcValuesHigh[fkTimeBins];
 
-//   AliPHOSCalibData* calib=0;
-
-//   //retrieve calibration database
-//   if(AliCDBManager::Instance()->IsDefaultStorageSet()){
-//     AliCDBEntry *entry = (AliCDBEntry*) AliCDBManager::Instance()->GetDefaultStorage()
-//       ->Get("PHOS/GainFactors_and_Pedestals/Calibration",gAlice->GetRunNumber());
-//     calib = (AliPHOSCalibData*) entry->GetObject();
-//   }
-
   // loop over digits (assume ordered digits)
   for (Int_t iDigit = 0; iDigit < digits->GetEntries(); iDigit++) {
     AliPHOSDigit* digit = dynamic_cast<AliPHOSDigit *>(digits->At(iDigit)) ;
@@ -512,16 +491,8 @@ void AliPHOS::Digits2Raw()
     } else {
       Double_t energy = 0 ;
       Int_t   module = relId[0];
-//       Int_t   column = relId[3];
-//       Int_t   row    = relId[2];
       if ( digit->GetId() <= geom->GetNModules() *  geom->GetNCristalsInModule()) {
-//     if(calib)
-//       energy = digit->GetAmp()*calib->GetADCchannelEmc(module,column,row) + 
-//         calib->GetADCpedestalEmc(module,column,row);
-//     else
-//       energy=digit->GetAmp()*digitizer->GetEMCchannel()+digitizer->GetEMCpedestal();
-//       } 
-       energy=digit->GetAmp();
+       energy=digit->GetAmp()*digitizer->GetEMCchannel() + digitizer->GetEMCpedestal();
       }
       else {
 //     energy = digit->GetAmp()*digitizer->GetCPVchannel()+digitizer->GetCPVpedestal();
@@ -529,9 +500,9 @@ void AliPHOS::Digits2Raw()
       }        
       Bool_t lowgain = RawSampledResponse(digit->GetTimeR(), energy, adcValuesHigh, adcValuesLow) ; 
       
-     if (lowgain) 
+      if (lowgain) 
        buffer->WriteChannel(relId[3], relId[2], module + fLowGainOffset, 
-                          GetRawFormatTimeBins(), adcValuesLow, kThreshold);
+                            GetRawFormatTimeBins(), adcValuesLow , kThreshold);
       else 
        buffer->WriteChannel(relId[3], relId[2], module, 
                             GetRawFormatTimeBins(), adcValuesHigh, kThreshold);
@@ -605,6 +576,10 @@ Bool_t AliPHOS::RawSampledResponse(Double_t dtime, Double_t damp, Int_t * adcH,
 {
   // for a start time dtime and an amplitude damp given by digit, 
   // calculates the raw sampled response AliPHOS::RawResponseFunction
+  // Input: dtime - signal start time
+  //        damp  - signal amplitude (energy)
+  // Output: adcH - array[fkTimeBins] of 10-bit samples for high-gain channel
+  //         adcL - array[fkTimeBins] of 10-bit samples for low-gain channel
 
   const Int_t kRawSignalOverflow = 0x3FF ; 
   Bool_t lowGain = kFALSE ; 

diff --git a/PHOS/AliPHOS.h b/PHOS/AliPHOS.h
index 4a2f4cff5c3c1b68717f01f01e5e63588c886a5c..33b1c79e37127941b52ac975ba664742e90ab477 100644 (file)
--- a/PHOS/AliPHOS.h
+++ b/PHOS/AliPHOS.h
@@ -7,6 +7,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.66  2006/03/24 21:39:33  schutz
+ * Modification needed to include PHOS in the global trigger framework
+ *
  * Revision 1.65  2006/03/07 18:56:25  kharlov
  * CDB is passed via environment variable
  *
@@ -43,7 +46,6 @@ class TRandom ;
 #include "AliLog.h"
 #include "AliPHOSGeometry.h" 
 #include "AliPHOSTrigger.h"
-class AliPHOSAlignData;
 
 class AliPHOS : public AliDetector {
 
@@ -70,8 +72,6 @@ public:
   virtual void  FinishRun() {;}
   virtual AliPHOSGeometry * GetGeometry() const 
   {return AliPHOSGeometry::GetInstance(GetTitle(),"") ;  }
-  virtual AliPHOSGeometry * GetGeometry(AliPHOSAlignData *alignda) const 
-  {return AliPHOSGeometry::GetInstance(GetTitle(),"",alignda) ;  }
 
   virtual void    Hits2SDigits();
   virtual Int_t   IsVersion(void) const = 0 ;  
@@ -113,7 +113,8 @@ protected:
   Double_t fHighLowGainFactor ;         // high to low gain factor for the raw RO signal
   Int_t    fLowGainOffset ;             // to separate high from low gain in the DDL
   static Int_t fgOrder ;                // order of the gamma function for the RO signal
-  static const Int_t fkTimeBins = 256 ; // number of sampling bins of the raw RO signal  
+//   static const Int_t fkTimeBins = 256 ; // number of sampling bins of the raw RO signal  
+  static const Int_t fkTimeBins = 64 ; // number of sampling bins of the raw RO signal  
   static Double_t fgTimeMax ;           // maximum sampled time of the raw RO signal                             
   static Double_t fgTimePeak ;          // peaking time of the raw RO signal                                    
   static Double_t fgTimeTrigger ;       // time of the trigger for the RO signal 

diff --git a/PHOS/AliPHOSGeometry.cxx b/PHOS/AliPHOSGeometry.cxx
index 273a68620097fcb2bfe2574a8836d4b3dbd89ae1..3677999be3d30e2c7260501ef1ea8b935a9ba52d 100644 (file)
--- a/PHOS/AliPHOSGeometry.cxx
+++ b/PHOS/AliPHOSGeometry.cxx
@@ -45,7 +45,6 @@ ClassImp(AliPHOSGeometry)
 // these initialisations are needed for a singleton
 AliPHOSGeometry  * AliPHOSGeometry::fgGeom = 0 ;
 Bool_t             AliPHOSGeometry::fgInit = kFALSE ;
-AliPHOSAlignData * AliPHOSGeometry::fgAlignData = 0 ;
 
 //____________________________________________________________________________
 AliPHOSGeometry::AliPHOSGeometry() {
@@ -83,16 +82,8 @@ void AliPHOSGeometry::Init(void)
 
   fgInit     = kTRUE ; 
 
-  // YK 23.02.2006
-  if(fgAlignData != NULL) {
-    // Number of modules is read from Alignment DB if exists
-    fNModules = fgAlignData->GetNModules();
-  }
-  else {
-    // Number of modules is fixed if Alignment DB does not exist
-    fNModules     = 5;
-    fAngle        = 20;
-  }
+  fNModules     = 5;
+  fAngle        = 20;
 
   fGeometryEMCA = new AliPHOSEMCAGeometry();
   
@@ -119,39 +110,22 @@ void AliPHOSGeometry::Init(void)
   
   fRotMatrixArray = new TObjArray(fNModules) ; 
 
-  // YK 23.02.2006
-  if(fgAlignData) {
-    // Geometry parameters are read from Alignment DB if exists
-
-    for (Int_t iModule=0; iModule<fNModules; iModule++) {
-      for (Int_t iXYZ=0; iXYZ<3; iXYZ++) {
-       fModuleCenter[iModule][iXYZ]   =
-         fgAlignData->GetModuleCenter(iModule,iXYZ);
-       fModuleAngle[iModule][iXYZ][0] = 
-         fgAlignData->GetModuleAngle(iModule,iXYZ,0);
-       fModuleAngle[iModule][iXYZ][1] = 
-         fgAlignData->GetModuleAngle(iModule,iXYZ,1);
-      }
-    }
-  }
-  else {
-    // Geometry parameters are calculated if Alignment DB does not exist
+  // Geometry parameters are calculated
 
-    SetPHOSAngles();
-    Double_t const kRADDEG = 180.0 / TMath::Pi() ;
-    Float_t r = GetIPtoOuterCoverDistance() + fPHOSParams[3] - GetCPVBoxSize(1) ;
-    for (Int_t iModule=0; iModule<fNModules; iModule++) {
-      fModuleCenter[iModule][0] = r * TMath::Sin(fPHOSAngle[iModule] / kRADDEG );
-      fModuleCenter[iModule][1] =-r * TMath::Cos(fPHOSAngle[iModule] / kRADDEG );
-      fModuleCenter[iModule][2] = 0.;
-
-      fModuleAngle[iModule][0][0] =  90;
-      fModuleAngle[iModule][0][1] =   fPHOSAngle[iModule];
-      fModuleAngle[iModule][1][0] =   0;
-      fModuleAngle[iModule][1][1] =   0;
-      fModuleAngle[iModule][2][0] =  90;
-      fModuleAngle[iModule][2][1] = 270 + fPHOSAngle[iModule];
-    }
+  SetPHOSAngles();
+  Double_t const kRADDEG = 180.0 / TMath::Pi() ;
+  Float_t r = GetIPtoOuterCoverDistance() + fPHOSParams[3] - GetCPVBoxSize(1) ;
+  for (Int_t iModule=0; iModule<fNModules; iModule++) {
+    fModuleCenter[iModule][0] = r * TMath::Sin(fPHOSAngle[iModule] / kRADDEG );
+    fModuleCenter[iModule][1] =-r * TMath::Cos(fPHOSAngle[iModule] / kRADDEG );
+    fModuleCenter[iModule][2] = 0.;
+    
+    fModuleAngle[iModule][0][0] =  90;
+    fModuleAngle[iModule][0][1] =   fPHOSAngle[iModule];
+    fModuleAngle[iModule][1][0] =   0;
+    fModuleAngle[iModule][1][1] =   0;
+    fModuleAngle[iModule][2][0] =  90;
+    fModuleAngle[iModule][2][1] = 270 + fPHOSAngle[iModule];
   }
 
 }
@@ -195,17 +169,6 @@ AliPHOSGeometry *  AliPHOSGeometry::GetInstance(const Text_t* name, const Text_t
   return rv ; 
 }
 
-//____________________________________________________________________________
-AliPHOSGeometry *  AliPHOSGeometry::GetInstance(const Text_t* name, const Text_t* title,
-                                               AliPHOSAlignData *alignda) 
-{
-  // Returns the pointer of the unique instance
-  // Creates it with the specified options (name, title) if it does not exist yet
-
-  fgAlignData = alignda;
-  return GetInstance(name,title);
-}
-
 //____________________________________________________________________________
 void AliPHOSGeometry::SetPHOSAngles() 
 { 

diff --git a/PHOS/AliPHOSGeometry.h b/PHOS/AliPHOSGeometry.h
index 249611b64e13d8050957949bb1caf4e8ad74a394..fa6e3893af871d141052916a6d31c54d414d6b17 100644 (file)
--- a/PHOS/AliPHOSGeometry.h
+++ b/PHOS/AliPHOSGeometry.h
@@ -24,7 +24,6 @@
 #include "AliPHOSEMCAGeometry.h"
 #include "AliPHOSCPVGeometry.h"
 #include "AliPHOSSupportGeometry.h"
-#include "AliPHOSAlignData.h"
 
 
 class AliPHOSGeometry : public AliGeometry {
@@ -39,8 +38,6 @@ public:
   
   virtual ~AliPHOSGeometry(void) ; 
   static AliPHOSGeometry * GetInstance(const Text_t* name, const Text_t* title="") ; 
-  static AliPHOSGeometry * GetInstance(const Text_t* name, const Text_t* title,
-                                      AliPHOSAlignData *alignda) ; 
   static AliPHOSGeometry * GetInstance() ; 
   virtual void   GetGlobal(const AliRecPoint* RecPoint, TVector3 & gpos, TMatrixF & gmat) const ;
   virtual void   GetGlobal(const AliRecPoint* RecPoint, TVector3 & gpos) const ;
@@ -150,9 +147,6 @@ public:
   void Init(void) ;            // steering method for PHOS and PPSD/CPV
 
 
-  void SetAlignData(AliPHOSAlignData* alignda) { fgAlignData = alignda; }
-  AliPHOSAlignData * AlignData() {return fgAlignData;}
-
 protected:
 
   AliPHOSGeometry(const Text_t* name, const Text_t* title="") : AliGeometry(name, title) { 
@@ -177,7 +171,6 @@ private:
 
   static AliPHOSGeometry * fgGeom ; // pointer to the unique instance of the singleton 
   static Bool_t fgInit ;            // Tells if geometry has been succesfully set up 
-  static AliPHOSAlignData * fgAlignData; // PHOS alignment data
 
   ClassDef(AliPHOSGeometry,2)       // PHOS geometry class 
 

diff --git a/PHOS/PHOSbaseLinkDef.h b/PHOS/PHOSbaseLinkDef.h
index 63623d632721b8ef9ebb632614d946fad107ef6f..04e6196f6a65e3a213b5ca86c2143b1b577c1767 100644 (file)
--- a/PHOS/PHOSbaseLinkDef.h
+++ b/PHOS/PHOSbaseLinkDef.h
@@ -25,7 +25,6 @@
 #pragma link C++ class AliPHOSFastRecParticle+;
 #pragma link C++ class AliPHOSRawStream2004+;
 #pragma link C++ class AliPHOSCalibData+;
-#pragma link C++ class AliPHOSAlignData+;
 #pragma link C++ class AliPHOSCpvCalibData+;
 #pragma link C++ class AliPHOSEmcCalibData+;
 

diff --git a/PHOS/libPHOSbase.pkg b/PHOS/libPHOSbase.pkg
index 237531789bb1a2f2c17fa848a5e216aec569666f..804224cd90b463dd3e4af08397ff5306299cf822 100644 (file)
--- a/PHOS/libPHOSbase.pkg
+++ b/PHOS/libPHOSbase.pkg
@@ -10,7 +10,7 @@ SRCS          =  AliPHOS.cxx \
                 AliPHOSCalibrationDB.cxx AliPHOSDigitizer.cxx \
                 AliPHOSSDigitizer.cxx AliPHOSDigit.cxx \
                 AliPHOSFastRecParticle.cxx AliPHOSRawStream2004.cxx \
-                AliPHOSCalibData.cxx AliPHOSAlignData.cxx \
+                AliPHOSCalibData.cxx \
                  AliPHOSCpvCalibData.cxx \
                  AliPHOSEmcCalibData.cxx
 

diff --git a/PHOS/macros/AlignmentDB/CreateMisalignment0.C b/PHOS/macros/AlignmentDB/CreateMisalignment0.C
new file mode 100644 (file)
index 0000000..73a6c96
--- /dev/null
+++ b/PHOS/macros/AlignmentDB/CreateMisalignment0.C
@@ -0,0 +1,43 @@
+void CreateMisalignment0(const Int_t nModules=5)
+{
+  // *************************    1st step    ***************
+  // Create TClonesArray of alignment objects for PHOS
+  // with ideal geometry, i.e. zero displacement and disorientations
+  // 
+  TClonesArray *array = new TClonesArray("AliAlignObjAngles",nModules);
+  TClonesArray &alobj = *array;
+   
+  AliAlignObjAngles a;
+
+  Double_t dx=0., dy=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
+  // null shifts and rotations
+
+  UShort_t iIndex=0;
+  AliAlignObj::ELayerID iLayer = AliAlignObj::kInvalidLayer;
+  UShort_t dvoluid = AliAlignObj::LayerToVolUID(iLayer,iIndex); //dummy volume identity 
+
+  TString basePath = "/ALIC_1/PHOS_"; 
+  
+  for (Int_t iModule = 1; iModule<=nModules; iModule++) {
+    printf("Alignment object for %s is created\n",(basePath+iModule).Data());
+    new(alobj[iModule-1]) AliAlignObjAngles((basePath+iModule).Data(),
+                                         dvoluid, dx, dy, dz, dpsi, dtheta, dphi);
+  }
+
+  // *************************    2nd step    ***************
+  // Make CDB storage and put TClonesArray in
+  // 
+  AliCDBManager *CDB = AliCDBManager::Instance();
+  CDB->SetDefaultStorage("local://$ALICE_ROOT");
+  
+  AliCDBMetaData *md= new AliCDBMetaData();
+  md->SetResponsible("Yuri Kharlov");
+  md->SetComment("Alignment objects for ideal geometry, i.e. applying them to TGeo has to leave geometry unchanged");
+  AliCDBId id("PHOS/Align/Data",0,0);
+  CDB->Put(array,id, md);
+}
+
+
+
+
+