"touch CMakeLists.txt" + update of upgrade CMakes
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 1 Aug 2012 23:25:19 +0000 (23:25 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 1 Aug 2012 23:25:19 +0000 (23:25 +0000)
ITS/CMakeLists.txt
ITS/UPGRADE/AliITSDetTypeSimUpg.cxx
ITS/UPGRADE/AliITSDetTypeSimUpg.h
ITS/UPGRADE/AliITSsimulationPixUpg.cxx
ITS/UPGRADE/CMakelibITSUpgradeBase.pkg
ITS/UPGRADE/CMakelibITSUpgradeSim.pkg
ITS/UPGRADE/ITSUpgradeBaseLinkDef.h
ITS/UPGRADE/ITSUpgradeSimLinkDef.h

index b0df30d..ea4b7ec 100644 (file)
@@ -8,6 +8,6 @@ cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
 file(GLOB PACKAGES CMake*.pkg)
 
 ALICE_BuildModule()
-
+#
 ADD_SUBDIRECTORY(UPGRADE)
 
index f7f21ef..914eb51 100644 (file)
@@ -45,6 +45,7 @@
 #include "AliITSTriggerConditions.h"
 #include "AliITSsegmentation.h"
 #include "AliITSsegmentationPixUpg.h"
+#include "AliITSsimulationPixUpg.h"
 #include "AliBaseLoader.h"
 
 using std::endl;
@@ -55,159 +56,37 @@ const char* AliITSDetTypeSimUpg::fgkDetTypeName[AliITSDetTypeSimUpg::kNDetTypes]
 
 
 //----------------------------------------------------------------------
-AliITSDetTypeSimUpg::AliITSDetTypeSimUpg():
-TObject(),
-fSimulation(),   // [NDet]
-fSegmentation(), // [NDet]
-fCalibration(),     // [NMod]
-fNSDigits(0),    //! number of SDigits
-fSDigits("AliITSpListItem",1000),   
-fNDigits(0),     //! number of Digits
-fRunNumber(0),   //! Run number (to access DB)
-fDigits(),       //! [NMod][NDigits]
-fSimuPar(0),
-fkDigClassName(), // String with digit class name.
-fLoader(0),      // local pointer to loader
-fFirstcall(kTRUE),
-fTriggerConditions(NULL)
+AliITSDetTypeSimUpg::AliITSDetTypeSimUpg() 
 { 
   // Default Constructor
+  // Note: the base class AliITSDetTypeSim is badly designed, since its 
+  // default c-tor dynamically creates lot of stuff. 
+  // To be derived directly from TObject later...
   // Inputs:
   //    none.
   // Outputs:
   //    none.
   // Return:
   //    A properly zero-ed AliITSDetTypeSimUpg class.
+  if (kNDetTypes>3) AliFatal("The hack failed: kNDetTypes>fgkNdettypes");
+  //
   for (int i=kNDetTypes;i--;) fDetNModules[i] = 0;
-  fSimulation   = new TObjArray(kNDetTypes);
-  fSegmentation = new TObjArray(kNDetTypes);
-  fSegmentation->SetOwner(kTRUE);
-  fDigits = new TObjArray(kNDetTypes);
-  fNDigits = new Int_t[kNDetTypes];
-  fSimuPar= new AliITSSimuParam();
-  SetRunNumber();
 }
 
 //----------------------------------------------------------------------
 AliITSDetTypeSimUpg::~AliITSDetTypeSimUpg()
 {
   // Destructor
-  // Inputs:
-  //    none.
-  // Outputs:
-  //    none.
-  // Return:
-  //    Nothing.
-  
-  if(fSimulation){
-    fSimulation->Delete();
-    delete fSimulation;
-  }
-  //
-  if(fSegmentation){
-    fSegmentation->Delete();
-    delete fSegmentation;
-  }
-  //
-  if(fCalibration && fRunNumber<0){
-    fCalibration->Delete();
-    delete fCalibration;
-  }
-  //
-  delete fSimuPar;
-  delete[] fNDigits;
-  //
-  if (fLoader)fLoader->GetModulesFolder()->Remove(this); // Not deleting it.
-  fSDigits.Delete();
-  if (fDigits) {
-    fDigits->Delete();
-    delete fDigits;
-  }
-  //
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::SetITSgeom(AliITSgeom *geom)
-{
-  // Sets/replaces the existing AliITSgeom object kept in AliITSLoader
-    // 
-    // Inputs:
-    //   AliITSgoem   *geom  The AliITSgeom object to be used.
-    // Output:
-    //   none.
-    // Return:
-    //   none.
-  if(!fLoader){
-    Error("SetITSgeom","No pointer to loader - nothing done");
-    return;
-  }
-  else {
-    fLoader->SetITSgeom(geom);  // protections in AliITSLoader::SetITSgeom
-  }
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::SetLoader(AliITSLoader *loader)
-{
-  // Sets the local copy of the AliITSLoader, and passes on the
-  // AliITSgeom object as needed.
-  // Inputs
-  //   AliITSLoader  *loader pointer to AliITSLoader for local use
-  // Outputs:
-  //   none.
-  // Return:
-  //  none.
-  
-  if(fLoader==loader) return; // Same do nothing
-  if(fLoader){ // alread have an existing loader
-    Error("SetLoader","Already have an exisiting loader ptr=%p Nothing done",fLoader);
-  } // end if
-  fLoader = loader;
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::SetSimulationModel(Int_t dettype,AliITSsimulation *sim)
-{
-  //Set simulation model for detector type
-  if(fSimulation==0) fSimulation = new TObjArray(kNDetTypes);
-  fSimulation->AddAt(sim,dettype);
-}
-
-//______________________________________________________________________
-AliITSsimulation* AliITSDetTypeSimUpg::GetSimulationModel(Int_t dettype) const 
-{ 
-  //Get simulation model for detector type
-  if(fSimulation==0)  {
-    Warning("GetSimulationModel","fSimulation is 0!");
-    return 0;     
-  }
-  return (AliITSsimulation*)(fSimulation->At(dettype));
-}
-
-//______________________________________________________________________
-AliITSsimulation* AliITSDetTypeSimUpg::GetSimulationModelByModule(Int_t module) const 
-{
-  //Get simulation model by module number
-  if(GetITSgeom()==0) {
-    Warning("GetSimulationModelByModule","GetITSgeom() is 0!");
-    return 0;
-  }
-  
-  return GetSimulationModel(GetITSgeom()->GetModuleType(module));
+  // RS: delegate everything to base class
 }
 
 //_______________________________________________________________________
 void AliITSDetTypeSimUpg::SetDefaultSegmentation(Int_t idet)
 {
   // Set default segmentation model objects
-  AliITSsegmentation *seg;
+  AliITSsegmentation *seg = 0;
   //  
-  if(fSegmentation==0x0){
-    fSegmentation = new TObjArray(kNDetTypes);
-    fSegmentation->SetOwner(kTRUE);
-  }
-  if (GetSegmentationModel(idet)) delete (AliITSsegmentation*)fSegmentation->RemoveAt(idet);
+  if (GetSegmentationModel(idet)) delete GetSegmentation()->RemoveAt(idet);
   //
   switch (idet) 
     {
@@ -218,92 +97,17 @@ void AliITSDetTypeSimUpg::SetDefaultSegmentation(Int_t idet)
   //
 }
 
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::SetSegmentationModel(Int_t dettype, AliITSsegmentation *seg)
-{
-  // Set segmentation model for detector type
-  if(fSegmentation==0x0){
-    fSegmentation = new TObjArray(kNDetTypes);
-    fSegmentation->SetOwner(kTRUE);
-  }
-  fSegmentation->AddAt(seg,dettype);
-}
-
-//______________________________________________________________________
-AliITSsegmentation* AliITSDetTypeSimUpg::GetSegmentationModel(Int_t dettype) const
-{
-  //Get segmentation model for detector type
-  
-  if(fSegmentation==0) {
-    Warning("GetSegmentationModel","fSegmentation is 0!");
-    return 0; 
-  } 
-  return (AliITSsegmentation*)(fSegmentation->At(dettype));
-}
-
-//_______________________________________________________________________
-AliITSsegmentation* AliITSDetTypeSimUpg::GetSegmentationModelByModule(Int_t module) const
-{
-  //Get segmentation model by module number
-  if(GetITSgeom()==0) {
-    Warning("GetSegmentationModelByModule","GetITSgeom() is 0!");
-    return 0;
-  }     
-  return GetSegmentationModel(GetITSgeom()->GetModuleType(module));
-  //
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::CreateCalibrationArray() 
-{
-  //Create the container of calibration functions with correct size
-  if (fCalibration) {
-    Warning("CreateCalibration","pointer to calibration object exists\n");
-    fCalibration->Delete();
-    delete fCalibration;
-  }
-  //
-  Int_t nModTot = GetITSgeom()->GetIndexMax();
-  fCalibration = new TObjArray(nModTot);
-  fCalibration->SetOwner(kTRUE);
-  fCalibration->Clear();
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::SetCalibrationModel(Int_t iMod, AliITSCalibration *resp)
-{
-  //Set response model for modules
-  
-  if (fCalibration==0) CreateCalibrationArray();
-  
-  if (fCalibration->At(iMod)!=0) delete (AliITSCalibration*) fCalibration->At(iMod);
-  fCalibration->AddAt(resp, iMod);
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::ResetCalibrationArray() 
-{
-  //resets response array
-  fCalibration->Clear();
-}
-
-//______________________________________________________________________
-void AliITSDetTypeSimUpg::ResetSegmentation()
-{
-  //Resets segmentation array
-  if(fSegmentation) fSegmentation->Clear();
-}
-
 //_______________________________________________________________________
 AliITSCalibration* AliITSDetTypeSimUpg::GetCalibrationModel(Int_t iMod) const 
 {
   //Get response model for module number iMod 
   //
-  if(fCalibration==0) {
-    AliError("fCalibration is 0!");
-    return 0; 
+  TObjArray* calarr = GetCalibrationArray();
+  if (!calarr) {
+    AliError("Calibration array is not initialized");
+    return 0;
   }
-  return (AliITSCalibration*)fCalibration->At(iMod);
+  return (AliITSCalibration*)calarr->At(iMod);
 }
 
 //_______________________________________________________________________
@@ -315,10 +119,10 @@ void AliITSDetTypeSimUpg::SetDefaults()
     Warning("SetDefaults","GetITSgeom() is 0!");
     return;
   } // end if
-  if (fCalibration==0) {
+  if (GetCalibrationArray()==0) {
     CreateCalibrationArray();
   } // end if
-  
+  //
   ResetSegmentation();
   if(!GetCalibration()){AliFatal("Exit"); exit(0);}
   
@@ -331,9 +135,11 @@ void AliITSDetTypeSimUpg::SetDefaults()
 }
 
 //______________________________________________________________________
-Bool_t AliITSDetTypeSimUpg::GetCalibration() {
+Bool_t AliITSDetTypeSimUpg::GetCalibration() 
+{
   // Get Default calibration if a storage is not defined.
-
+  /*
+  //
   if(!fFirstcall){
     AliITSCalibration* cal = GetCalibrationModel(0);
     if(cal)return kTRUE;
@@ -357,6 +163,7 @@ Bool_t AliITSDetTypeSimUpg::GetCalibration() {
   AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
   //
   // TO DO, RS
+  */
   return kTRUE;
 }
 
@@ -369,11 +176,11 @@ void AliITSDetTypeSimUpg::SetDefaultSimulation()
     Warning("SetDefaultSimulation","GetITSgeom() is 0!");
     return;
   }
-  if (fCalibration==0) {
+  if (GetCalibrationArray()==0) {
     Warning("SetDefaultSimulation","fCalibration is 0!");
     return;
   }
-  if (fSegmentation==0) {
+  if (GetSegmentation()==0) {
     Warning("SetDefaultSimulation","fSegmentation is 0!");
     for (Int_t i=0;i<kNDetTypes;i++) SetDefaultSegmentation(i);
   } else for(Int_t i=0;i<kNDetTypes;i++) if(!GetSegmentationModel(i)){
@@ -385,10 +192,10 @@ void AliITSDetTypeSimUpg::SetDefaultSimulation()
   AliITSsimulation* sim;
   //
   for (Int_t idet=0;idet<kNDetTypes;idet++) {
-    //OixUpg
-    if(idet==0){
+    //PixUpg
+    if (idet==kDetPixUpg) {
       sim = GetSimulationModel(idet); 
-      if(!sim){
+      if (!sim) {
        sim = new AliITSsimulationPixUpg(this);
        SetSimulationModel(idet,sim);
       }
@@ -396,133 +203,18 @@ void AliITSDetTypeSimUpg::SetDefaultSimulation()
   }
 }
 
-//___________________________________________________________________
-void AliITSDetTypeSimUpg::SetTreeAddressS(TTree* treeS, const Char_t* name)
-{
-  // Set branch address for the ITS summable digits Trees.  
-
-  if(!treeS) return;
-  TBranch *branch;
-  branch = treeS->GetBranch(name);
-  TClonesArray *sdigi = &fSDigits;
-  if (branch) branch->SetAddress(&sdigi);
-
-}
-
-//___________________________________________________________________
-void AliITSDetTypeSimUpg::SetTreeAddressD(TTree* treeD, const Char_t* name)
-{
-  // Set branch address for the digit Trees.
-  TBranch *branch; 
-  TString branchname;
-  //
-  if(!treeD) return;
-  //
-  if(!fDigits) fDigits = new TObjArray(kNDetTypes); 
-  //
-  for(Int_t i=0;i<kNDetTypes;i++){
-    const Char_t* digclass = GetDigitClassName(i);
-    if(digclass==0x0){
-      if(i==0) SetDigitClassName(i,Form("AliITSdigit%s",fgkDetTypeName[i]));
-      digclass = GetDigitClassName(i);
-    }
-    TString classn = digclass;
-    if(!(fDigits->At(i))){
-      fDigits->AddAt(new TClonesArray(classn.Data(),1000),i);
-    }else{
-      ResetDigits(i);
-    }
-    //
-    if(kNDetTypes==3) branchname.Form("%sDigits%s",name,fgkDetTypeName[i]);
-    branch = treeD->GetBranch(branchname.Data());
-    if(branch) branch->SetAddress(&((*fDigits)[i]));    
-  }
-}
-
-//___________________________________________________________________
-void AliITSDetTypeSimUpg::ResetDigits()
-{
-  // Reset number of digits and the digits array for the ITS detector.  
-  //
-  if(!fDigits){
-    Error("ResetDigits","fDigits is null!");
-    return;
-  }
-  for(Int_t i=0;i<kNDetTypes;i++) ResetDigits(i);
-  //
-}
-
-//___________________________________________________________________
-void AliITSDetTypeSimUpg::ResetDigits(Int_t branch)
-{
-  // Reset number of digits and the digits array for this branch.
-  //
-  if (fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
-  if(fNDigits) fNDigits[branch]=0;
-}
-
-//_______________________________________________________________________
-void AliITSDetTypeSimUpg::SDigitsToDigits(Option_t* opt, Char_t* name)
-{
-  // Standard Summable digits to Digits function.
-  if(!GetITSgeom()){
-    Warning("SDigitsToDigits","GetITSgeom() is null!!");
-    return;
-  }
-  //
-  static Bool_t setDef = kTRUE;
-  if(setDef) SetDefaultSimulation();
-  setDef = kFALSE;
-  //
-  AliITSsimulation *sim =0;
-  TTree* trees = fLoader->TreeS();
-  if( !(trees && GetSDigits()) ){
-    Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
-    return;
-  } 
-  //
-  TBranch* brchSDigits = trees->GetBranch(name);
-  //
-  Int_t id;
-  for(Int_t module=0;module<GetITSgeom()->GetIndexMax();module++) {
-    //
-    id = GetITSgeom()->GetModuleType(module);
-    sim = (AliITSsimulation*)GetSimulationModel(id);
-    if(!sim){
-      AliFatal(Form("The simulation class was not instanciated for module %d type %s!",
-                   module,GetITSgeom()->GetModuleTypeName(module)));
-    }
-    sim->InitSimulationModule(module,gAlice->GetEvNumber());
-    //
-    fSDigits.Clear();
-    brchSDigits->GetEvent(module);
-    sim->AddSDigitsToModule(&fSDigits,0);
-    sim->FinishSDigitiseModule();
-    fLoader->TreeD()->Fill();
-    ResetDigits();
-  }
-  //
-  //  WriteFOSignals(); 
-  fLoader->TreeD()->GetEntries();
-  fLoader->TreeD()->AutoSave();
-  fLoader->TreeD()->Reset();
-}
-
-//_________________________________________________________
-void AliITSDetTypeSimUpg::AddSumDigit(AliITSpListItem &sdig)
-{  
-  //Adds the module full of summable digits to the summable digits tree.
-  new(fSDigits[fNSDigits++]) AliITSpListItem(sdig);
-}
 
 //__________________________________________________________
 void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch, const AliITSdigit* d)
 {  
   // Add a simulated digit.
-  TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
+  TClonesArray* ldigits = DigitsAddress(branch);
+  if (!ldigits) AliFatal(Form("Digits array for detector %d is not initialized",branch));
+  int* ndig = GetNDigitArray();
+  //
   switch(branch){
   case kDetPixUpg:
-    new(ldigits[fNDigits[branch]++]) AliITSdigitPixUpg(*((AliITSdigitPixUpg*)d));
+    new( (*ldigits)[ndig[branch]++]) AliITSdigitPixUpg(*((AliITSdigitPixUpg*)d));
     break;
   default:
     AliFatal(Form("Digit for unknown detector type %d",branch));
@@ -536,43 +228,15 @@ void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
 {
   //   Add a simulated digit to the list.
 
-  TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
+  TClonesArray *ldigits = DigitsAddress(branch);
+  if (!ldigits) AliFatal(Form("Digits array for detector %d is not initialized",branch));
+  int* ndig = GetNDigitArray();
+  //
   switch(branch){
   case kDetPixUpg:
-    new(ldigits[fNDigits[branch]++]) AliITSdigitPixUpg(digits,tracks,hits);
+    new((*ldigits)[ndig[branch]++]) AliITSdigitPixUpg(digits,tracks,hits);
     break;
   default:
     AliFatal(Form("Digit for unknown detector type %d",branch));
   } 
 }
-
-//_______________________________________________________________________
-AliITSTriggerConditions* AliITSDetTypeSimUpg::GetTriggerConditions() 
-{
-  // Get Pixel Trigger Conditions (separate method since it is used only when simulating trigger)
-  if (fTriggerConditions==NULL) { // read from db
-    fRunNumber = ((Int_t)AliCDBManager::Instance()->GetRun());
-    Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag();
-    Bool_t isCacheActive;
-    if (fRunNumber<0) isCacheActive=kFALSE;
-    else              isCacheActive=kTRUE;
-    AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
-    AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions", fRunNumber);
-    if (!pitCond) {
-      AliError("Trigger conditions retrieval failed! ");
-      return NULL;
-    }
-    fTriggerConditions = (AliITSTriggerConditions*) pitCond->GetObject();
-    if (!isCacheActive) pitCond->SetObject(NULL);
-    pitCond->SetOwner(kTRUE);
-    if (!isCacheActive) {
-      delete pitCond;
-    }
-    AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
-    if (fTriggerConditions==NULL) {
-      AliWarning("fTriggerConditions is NULL!");
-    }
-  }
-  return fTriggerConditions;
-}
-
index 5445062..b113b87 100644 (file)
@@ -15,6 +15,7 @@
 #include <TObject.h>
 #include "AliITSLoader.h"
 #include "AliITSSimuParam.h"
+#include "AliITSDetTypeSim.h"
 
 class TObjArray;
 class TClonesArray;
@@ -31,98 +32,38 @@ class AliITSCalibration;
 class AliITSgeom;
 class AliITSTriggerConditions;
 
-class AliITSDetTypeSimUpg : public TObject {
+
+class AliITSDetTypeSimUpg : public AliITSDetTypeSim {
  public:
   //
   enum {kDetPixUpg, kNDetTypes};
   //  
   AliITSDetTypeSimUpg();
   virtual ~AliITSDetTypeSimUpg(); 
-  AliITSgeom *GetITSgeom() const {if(fLoader)return ((AliITSLoader*)fLoader)->GetITSgeom(); else return 0;}
-  void SetITSgeom(AliITSgeom *geom);
-  
-  virtual void SetSimulationModel(Int_t dettype,AliITSsimulation *sim);
-  virtual AliITSsimulation* GetSimulationModel(Int_t dettype) const;        
-  virtual AliITSsimulation* GetSimulationModelByModule(Int_t module) const;
-  
-  virtual void SetSegmentationModel(Int_t dettype,AliITSsegmentation *seg);
-  virtual AliITSsegmentation* GetSegmentationModel(Int_t dettype) const;
-  virtual AliITSsegmentation* GetSegmentationModelByModule(Int_t module) const;
-  
-  virtual void SetCalibrationModel(Int_t iMod,AliITSCalibration *resp);
   
   virtual AliITSCalibration* GetCalibrationModel(Int_t iMod) const;
   virtual AliITSTriggerConditions* GetTriggerConditions();
   
-  virtual void SetSimuParam(const AliITSSimuParam* spar){
-    if(fSimuPar) delete fSimuPar;
-    fSimuPar = new AliITSSimuParam(*spar);
-  }
-  virtual AliITSSimuParam* GetSimuParam() const {return fSimuPar;}
-  
-  TObjArray* GetCalibrationArray() const {return fCalibration;}
-  TObjArray* GetSegmentation() const {return fSegmentation;}
-  void ResetCalibrationArray();
-  void ResetSegmentation();
-  
-  virtual void SetLoader(AliITSLoader* loader);
-  AliITSLoader* GetLoader() const {return fLoader;}
-  
   virtual void SetDefaults();
   virtual void SetDefaultSimulation();
-  virtual void SetRunNumber(Int_t rn=0){fRunNumber = rn;}
-  virtual Int_t GetRunNumber() const {return fRunNumber;}
-  virtual void SetTreeAddressS(TTree* treeS, const Char_t* name);
-  virtual void SetTreeAddressD(TTree* treeD, const Char_t* name);
-  
-  virtual void SetDigits(TObjArray* digits) {fDigits=digits;}
-  const TClonesArray* GetSDigits() const { return &fSDigits;}
-  TObjArray*    GetDigits() const {return fDigits;}
-  Int_t* GetNDigitArray() const {return fNDigits;}
-  TClonesArray *DigitsAddress(Int_t id) const { return ((TClonesArray*)(*fDigits)[id]);}
-  virtual void ResetSDigits(){fNSDigits=0; fSDigits.Clear();}
-  virtual void ResetDigits();
-  virtual void ResetDigits(Int_t branch);
-  virtual void SDigitsToDigits(Option_t *opt, Char_t* name);
-
-  virtual void AddSumDigit(AliITSpListItem &sdig);
+  //
   virtual void AddSimDigit(Int_t branch, const AliITSdigit *d);
   virtual void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
                           Int_t* tracks,Int_t *hits,Float_t* trkcharges,
                           Int_t sigexpanded=-1000);
-  virtual void SetDigitClassName(Int_t i, const Char_t* name) {fkDigClassName[i]=name;}
-  const Char_t* GetDigitClassName(Int_t i) const {return fkDigClassName[i];}
-
-
 
  protected:
-  virtual void CreateCalibrationArray(); 
   virtual Bool_t GetCalibration();
     
  private:
   AliITSDetTypeSimUpg(const AliITSDetTypeSimUpg &source);
   AliITSDetTypeSimUpg& operator=(const AliITSDetTypeSimUpg &source);
   void SetDefaultSegmentation(Int_t idet);  // creates def segm.
-
   //
   Int_t              fDetNModules[kNDetTypes]; // Total numbers of modules of each type, RS
-  //
-  TObjArray    *fSimulation;   //! [NDet]
-  TObjArray    *fSegmentation; //! [NDet]
-  TObjArray    *fCalibration;  //! [NMod]
-  Int_t         fNSDigits;     //! number of SDigits
-  TClonesArray  fSDigits;      //! Summable digits
-  Int_t*        fNDigits;      //! [NDet] number of Digits for det.
-  Int_t         fRunNumber;    //! run number (to access DB)
-  TObjArray     *fDigits;      //! [NMod][NDigits]
-  AliITSSimuParam *fSimuPar;   //! detector simulation parameters
-  const Char_t*    fkDigClassName[kNDetTypes]; //! String with digit class name.
-  AliITSLoader* fLoader;          //! loader  
-  Bool_t        fFirstcall;       //! flag
-  AliITSTriggerConditions* fTriggerConditions; //! Trigger conditions 
-  //
-  static const char* fgkDetTypeName[kNDetTypes];  // detector type names
   //       
+  static const char* fgkDetTypeName[kNDetTypes]; // detector names
+  //
   ClassDef(AliITSDetTypeSimUpg,1) // ITS Upg Simulation structure
  
 };
index d6c94c2..848d7fc 100644 (file)
@@ -77,7 +77,7 @@ fStrobePhase(-12.5e-9)
 }
 
 //______________________________________________________________________
-AliITSsimulationPixUpg::AliITSsimulationPixUpg(AliITSDetTypeSim *dettyp):
+AliITSsimulationPixUpg::AliITSsimulationPixUpg(AliITSDetTypeSimUpg *dettyp):
 AliITSsimulation(dettyp),
 fHistos(0),
 fHistName(),
@@ -120,12 +120,12 @@ void AliITSsimulationPixUpg::Init()
   SetMap(new AliITSpList(GetNPixelsZ(),GetNPixelsX()));
   AliITSSimuParam* simpar = fDetType->GetSimuParam();
   AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
-  Double_t bias = simpar->GetPixBiasVoltage();
+  Double_t bias = simpar->GetSPDBiasVoltage(); //RS !!!
 //    cout << "Bias Voltage --> " << bias << endl; // dom    
    simpar->SetDistanceOverVoltage(kmictocm*seg->Dy(),bias);
 // set kind of coupling ("old" or "new")
-   char opt[20];
-   simpar->GetPixCouplingOption(opt);
+   char opt[20] = {"new"};
+   //   simpar->GetSPDCouplingOption(opt); //RS !!!
    char *old = strstr(opt,"old");
    if (old) {
      fCoupling=2;
@@ -597,7 +597,7 @@ void AliITSsimulationPixUpg::SpreadCharge(Double_t x0,Double_t z0,
    Int_t ix,iz,ixs,ixe,izs,ize;
    Float_t x,z;
    Double_t x1,x2,z1,z2,s,sp;
-   AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(-1);
+   AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
    //
    if (GetDebug(4)) Info("SpreadCharge","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sig=%e,t=%d,i=%d)",x0,z0,ix0,iz0,el,sig,t,hi);
    if (sig<=0.0) { // if sig<=0 No diffusion to simulate.
@@ -669,7 +669,7 @@ void AliITSsimulationPixUpg::SpreadChargeAsym(Double_t x0,Double_t z0,
    Int_t ix,iz,ixs,ixe,izs,ize;
    Float_t x,z;
    Double_t x1,x2,z1,z2,s,spx,spz;
-   AliITSsegmentationSPD* seg = (AliITSsegmentationSPD*)GetSegmentationModel(-1);
+   AliITSsegmentationPixUpg* seg = (AliITSsegmentationPixUpg*)GetSegmentationModel(-1);
    //
    if (GetDebug(4)) Info("SpreadChargeAsym","(x0=%e,z0=%e,ix0=%d,iz0=%d,el=%e,sigx=%e, sigz=%e, t=%d,i=%d)",x0,z0,ix0,iz0,el,sigx,sigz,t,hi);
    if (sigx<=0.0 || sigz<=0.0) { // if sig<=0 No diffusion to simulate.
@@ -729,7 +729,7 @@ void AliITSsimulationPixUpg::AddNoisyPixels()
   // Adds noisy pixels on each module (ladder)
   // This should be called before going from sdigits to digits (FrompListToDigits)
   Int_t mod = GetModuleNumber();
-  AliITSCalibrationPixUpg* calObj = (AliITSCalibrationPixUpg*) fDetType->GetPixNoisyModel(mod);
+  AliITSCalibrationPixUpg* calObj = (AliITSCalibrationPixUpg*) fDetType->GetSPDNoisyModel(mod); // RS !!!
   //
   Int_t nrNoisy = calObj->GetNrBad();
   for (Int_t i=0; i<nrNoisy; i++) {
@@ -754,7 +754,7 @@ void AliITSsimulationPixUpg::FrompListToDigits()
   Double_t  electronics;
   Double_t sig;
   const Int_t    knmaxtrk=AliITSdigit::GetNTracks();
-  static AliITSdigitSPD dig;
+  static AliITSdigitPixUpg dig;
   AliITSSimuParam *simpar = fDetType->GetSimuParam();
   if (GetDebug(1)) Info("FrompListToDigits","()");
   for (iz=0; iz<GetNPixelsZ(); iz++) 
@@ -783,7 +783,7 @@ void AliITSsimulationPixUpg::FrompListToDigits()
        AliWarning(Form("Too big or too small signal value %f",aSignal));
        aSignal = TMath::Sign((Double_t)2147483647,aSignal);
       }
-      dig.SetSignalSPD((Int_t)aSignal);
+      dig.SetSignalPix((Int_t)aSignal);
       
       for (j=0;j<knmaxtrk;j++) {
        if (j<GetMap()->GetNEntries()) {
index 97b7286..a13bbd6 100644 (file)
@@ -34,7 +34,6 @@ AliITSInitGeometryUpg.cxx
 AliITSLoaderUpg.cxx 
 AliITSgeomTGeoUpg.cxx
 AliITSCalibrationPixUpg.cxx
-AliITSsegmentationPixUpg.cxx
 )
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
index 5789465..999a45a 100644 (file)
@@ -33,6 +33,8 @@ AliITSUpg.cxx
 AliITSvUpgrade.cxx 
 AliITSv11GeometryUpgrade.cxx 
 AliITSv11GeomBeamPipe.cxx
+AliITSDetTypeSimUpg.cxx
+AliITSsimulationPixUpg.cxx
 )
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
index aa21225..0e1420e 100644 (file)
@@ -19,6 +19,4 @@
 #pragma link C++ class  AliITSLoaderUpg+;
 #pragma link C++ class  AliITSgeomTGeoUpg+;
 #pragma link C++ class  AliITSCalibrationPixUpg+;
-#pragma link C++ class  AliITSsegmentationPixUpg+;
-
 #endif
index 40a185b..38a730b 100644 (file)
@@ -21,6 +21,7 @@
 #pragma link C++ class  AliITSvUpgrade+;
 #pragma link C++ class  AliITSv11GeometryUpgrade+;
 #pragma link C++ class  AliITSv11GeomBeamPipe+;
-
+#pragma link C++ class  AliITSDetTypeSimUpg+;
+#pragma link C++ class  AliITSsimulationPixUpg+;
 
 #endif