X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITS.cxx;h=3485d1fd44a76e89325122e31fdc2aee76990241;hb=05da1b4e2007170ee10c3a94cfef582320a3d258;hp=e83e8878b6a84ab757390de61be6e221aae722d8;hpb=a5a317a966a4f115089fa758bc2c58f8d4354e3b;p=u%2Fmrichter%2FAliRoot.git

diff --git a/ITS/AliITS.cxx b/ITS/AliITS.cxx
index e83e8878b6a..3485d1fd44a 100644
--- a/ITS/AliITS.cxx
+++ b/ITS/AliITS.cxx
@@ -72,6 +72,7 @@ the AliITS class.
 #include <TString.h>
 #include <TTree.h>
 #include <TVirtualMC.h>
+#include <TArrayI.h>
 #include "AliDetector.h"
 #include "AliITS.h"
 #include "AliITSDetTypeSim.h"
@@ -112,7 +113,9 @@ fIdSens(0),
 fIdName(0),
 fITSmodules(0),
 fTiming(kFALSE),
-fSimuParam(0)
+fSimuParam(0),
+fModA(0),
+fpSDigits(0)
 {
   // Default initializer for ITS
   //      The default constructor of the AliITS class. In addition to
@@ -123,6 +126,7 @@ fSimuParam(0)
   
 //    SetDetectors(); // default to fOpt="All". This variable not written out.
 //PH    SetMarkerColor(kRed);
+  for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
 }
 //______________________________________________________________________
 AliITS::AliITS(const Char_t *title):
@@ -135,7 +139,9 @@ AliITS::AliITS(const Char_t *title):
   fIdName(0),
   fITSmodules(0),
   fTiming(kFALSE),
-  fSimuParam(0)
+  fSimuParam(0),
+  fModA(0),
+  fpSDigits(0)
 {
     //     The standard Constructor for the ITS class. 
     // It also zeros the variables
@@ -161,6 +167,7 @@ AliITS::AliITS(const Char_t *title):
     //PH  SetMarkerColor(kRed);
     if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
     fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
+    for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
 }
 //______________________________________________________________________
 AliITS::AliITS(const char *name, const char *title):
@@ -173,7 +180,9 @@ AliITS::AliITS(const char *name, const char *title):
   fIdName(0),
   fITSmodules(0),
   fTiming(kFALSE),
-  fSimuParam(0)
+  fSimuParam(0),
+  fModA(0),
+  fpSDigits(0)
 {
   //     The standard Constructor for the ITS class. 
   // It also zeros the variables
@@ -195,7 +204,7 @@ AliITS::AliITS(const char *name, const char *title):
   //PH  SetMarkerColor(kRed);
   if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
   fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-
+  for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
 }
 //______________________________________________________________________
 AliITS::~AliITS(){
@@ -223,7 +232,7 @@ AliITS::~AliITS(){
 
     delete[] fIdName;  // Array of TStrings
     delete[] fIdSens;
-
+    Int_t size   = AliITSgeomTGeo::GetNModules();
     if (fDetTypeSim){
       delete fDetTypeSim;
       fDetTypeSim = 0;
@@ -232,20 +241,34 @@ AliITS::~AliITS(){
       delete fSimuParam;
       fSimuParam=0;
     }
+    if(fModA){
+      if(size>0){
+	for(Int_t j=0; j<size; j++){
+	  fModA[j]->Delete();
+	  delete fModA[j];
+	}
+      }
+      delete []fModA;
+    }
+    if(fpSDigits){
+      fpSDigits->Delete();
+      delete fpSDigits;
+    }
 }
+
 //______________________________________________________________________
-AliDigitizer* AliITS::CreateDigitizer(AliRunDigitizer* manager)const{
+AliDigitizer* AliITS::CreateDigitizer(AliDigitizationInput* digInput)const{
     // Creates the AliITSDigitizer in a standard way for use via AliModule.
     // This function can not be included in the .h file because of problems
     // with the order of inclusion (recursive).
     // Inputs:
-    //    AliRunDigitizer *manager  The Manger class for Digitization
+    //    AliDigitizationInput* digInput  The Manger class for Digitization
     // Output:
     //    none.
     // Return:
     //    A new AliITSRunDigitizer (cast as a AliDigitizer).
 
-     return new AliITSDigitizer(manager);
+     return new AliITSDigitizer(digInput);
 }
 //______________________________________________________________________
 void AliITS::Init(){
@@ -349,10 +372,10 @@ void AliITS::MakeBranchS(const char* fl){
     Error("MakeBranchS","fDetTypeSim is 0!");
   }
   Int_t buffersize = 4000;
-  char branchname[30];
+  char branchname[31];
 
   // only one branch for SDigits.
-  sprintf(branchname,"%s",GetName());
+  snprintf(branchname,30,"%s",GetName());
 
   if(fLoader->TreeS()){
     TClonesArray* sdig = (TClonesArray*)fDetTypeSim->GetSDigits();
@@ -385,7 +408,7 @@ void AliITS:: MakeBranchInTreeD(TTree* treeD, const char* file){
   const Char_t *det[3] = {"SPD","SDD","SSD"};
   const Char_t* digclass;
   Int_t buffersize = 4000;
-  Char_t branchname[30];
+  Char_t branchname[31];
   
   if(!fDetTypeSim->GetDigits()){
     fDetTypeSim->SetDigits(new TObjArray(fgkNTYPES));
@@ -397,7 +420,7 @@ void AliITS:: MakeBranchInTreeD(TTree* treeD, const char* file){
       (fDetTypeSim->GetDigits())->AddAt(new TClonesArray(classn.Data(),1000),i);
     }
     else ResetDigits(i);  
-    if(fgkNTYPES==3) sprintf(branchname,"%sDigits%s",GetName(),det[i]);
+    if(fgkNTYPES==3) snprintf(branchname,30,"%sDigits%s",GetName(),det[i]);
     else sprintf(branchname,"%sDigits%d",GetName(),i+1);
     TObjArray* dig = DigitsAddress(i);
     if(GetDigits() && treeD) AliDetector::MakeBranchInTree(treeD,branchname, &dig,buffersize,file);
@@ -453,7 +476,7 @@ void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
 }
 
 //______________________________________________________________________
-void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
+void AliITS::FillModules(Int_t /* evnt */,Int_t bgrev,Int_t /* nmodules */,
                          Option_t *option, const char *filename){
   // fill the modules with the sorted by module hits; add hits from
   // background if option=Add.
@@ -463,7 +486,6 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
   static TFile *file;
   const char *addBgr = strstr(option,"Add");
   
-  evnt = nmodules; // Dummy use of variables to remove warnings
   if (addBgr ) {
     if(first) {
       file=new TFile(filename);
@@ -475,8 +497,8 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
     if(trH1) delete trH1;
     trH1=0;
     
-    char treeName[20];
-    sprintf(treeName,"TreeH%d",bgrev);
+    char treeName[21];
+    snprintf(treeName,20,"TreeH%d",bgrev);
     trH1 = (TTree*)gDirectory->Get(treeName);
     if (!trH1) {
       Error("FillModules","cannot find Hits Tree for event:%d",bgrev);
@@ -490,8 +512,10 @@ void AliITS::FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
     FillModules(trH1,10000000); // Default mask 10M.
     TTree *fAli=fLoader->GetRunLoader()->TreeK();
     TFile *fileAli=0;
-    if (fAli) fileAli =fAli->GetCurrentFile();
-    fileAli->cd();
+    if (fAli) {
+      fileAli =fAli->GetCurrentFile();
+      fileAli->cd();
+    }
   } // end if add
   
   
@@ -512,13 +536,14 @@ void AliITS::FillModules(TTree *treeH, Int_t mask) {
 
     if (treeH == 0x0)
      {
-       Error("FillModules","Tree is NULL");
+       AliError("Tree H  is NULL");
+       return;
      }
     Int_t lay,lad,det,index;
     AliITShit *itsHit=0;
     AliITSmodule *mod=0;
-    char branchname[20];
-    sprintf(branchname,"%s",GetName());
+    char branchname[21];
+    snprintf(branchname,20,"%s",GetName());
     TBranch *branch = treeH->GetBranch(branchname);
     if (!branch) {
         Error("FillModules","%s branch in TreeH not found",branchname);
@@ -726,16 +751,10 @@ void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
   
   ClearModules();
  
-  // Add random noise to FO signals
-  if (all || det[0]) { // SPD present
-    fDetTypeSim->ProcessNoiseForFastOr();
-  }
-
   // Add Fast-OR signals to event (only one object per event)
   if (all || det[0]) { // SPD present
-    fDetTypeSim->WriteFOSignals();
+    WriteFOSignals();
   }
-
   
   fLoader->TreeD()->GetEntries();
   fLoader->TreeD()->AutoSave();
@@ -988,7 +1007,6 @@ void AliITS::SDigitsToDigits(Option_t *opt){
     AliError("fDetTypeSim is 0!");
     return;
   }
-
   const char *all = strstr(opt,"All");
   const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),
 		       strstr(opt,"SSD")};
@@ -1001,13 +1019,9 @@ void AliITS::SDigitsToDigits(Option_t *opt){
   if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
   fDetTypeSim->SDigitsToDigits(opt,(Char_t*)GetName());
 
-  // Add random noise to FO signals
-  if (all || det[0]) { // SPD present
-    fDetTypeSim->ProcessNoiseForFastOr();
-  }
   // Add Fast-OR signals to event (only one object per event)
   if (all || det[0]) { // SPD present
-    fDetTypeSim->WriteFOSignals();
+   WriteFOSignals();
   }
 }
 
@@ -1196,170 +1210,195 @@ Bool_t AliITS::Raw2SDigits(AliRawReader* rawReader)
   //
   // Get TreeS
   //
-    Int_t last   = -1;
-    Int_t size   = GetITSgeom()->GetIndexMax();
-    TClonesArray** modA = new TClonesArray*[size];
-    for (Int_t mod = 0; mod < size; mod++) modA[mod] = new TClonesArray("AliITSpListItem", 10000);
-    
-    AliLoader* loader =  (AliRunLoader::Instance())->GetLoader("ITSLoader");
-    if (!loader){
-	Error("Open","Can not get ITS loader from Run Loader");
-	return kFALSE;
-    }
+  Int_t last   = -1;
+  Int_t size   = AliITSgeomTGeo::GetNModules();
+  if(!fModA) {
+    fModA = new TClonesArray*[size];
+    for (Int_t mod = 0; mod < size; mod++) fModA[mod] = new TClonesArray("AliITSpListItem", 10000);
+  }
+  AliLoader* loader =  (AliRunLoader::Instance())->GetLoader("ITSLoader");
+  if (!loader){
+    Error("Open","Can not get ITS loader from Run Loader");
+    return kFALSE;
+  }
 
-    TTree* tree = 0;
+  TTree* tree = 0;
+  tree = loader->TreeS();
+  if (!tree){
+    loader->MakeTree("S");
     tree = loader->TreeS();
-    if (!tree){
-	loader->MakeTree("S");
-	tree = loader->TreeS();
-    }
-    //
-    // Array for SDigits
-    // 
-    TClonesArray aSDigits("AliITSpListItem",10000), *itsSDigits=&aSDigits;
-    Int_t bufsize = 32000;
-    tree->Branch("ITS", &itsSDigits, bufsize);
-    Int_t npx = 0;
-    //
-    // SPD
-    //
-    AliITSsegmentationSPD* segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
-    if(!segSPD){
-      AliWarning("Set AliITS defaults");
-      SetDefaults();
-      segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
-    }
-    npx = segSPD->Npx();
-    Double_t thr, sigma; 
-    
-    AliITSRawStreamSPD inputSPD(rawReader);
-    while(1){
-	Bool_t next  = inputSPD.Next();
-	if (!next) break;
-
-	Int_t module = inputSPD.GetModuleID();
-	Int_t column = inputSPD.GetColumn();
-	Int_t row    = inputSPD.GetRow();
-	Int_t index  = npx * column + row;
-
-	if (module >= size) continue;
+  }
+  //
+  // Array for SDigits
+  // 
+  if(!fpSDigits){
+    fpSDigits = new TClonesArray("AliITSpListItem",10000);
+  }
+  TClonesArray& aSDigits = *fpSDigits;
+  Int_t bufsize = 32000;
+  tree->Branch("ITS", &fpSDigits, bufsize);
+  Int_t npx = 0;
+  //
+  // SPD
+  //
+  AliITSsegmentationSPD* segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
+  if(!segSPD){
+    AliWarning("Set AliITS defaults");
+    SetDefaults();
+    segSPD = (AliITSsegmentationSPD*) fDetTypeSim->GetSegmentationModel(0);
+  }
+  npx = segSPD->Npx();
+  Double_t thr, sigma; 
+
+  Int_t countRW = -1; // RS counter for raw -> cluster ID's (used in embedding)
+  const TArrayI* rawID2clusID = fkRawID2ClusID[kSPD];
+  AliITSRawStreamSPD inputSPD(rawReader);
+  while(1){
+    Bool_t next  = inputSPD.Next();
+    if (!next) break;
+
+    countRW++; // RS
+    Int_t module = inputSPD.GetModuleID();
+    Int_t column = inputSPD.GetColumn();
+    Int_t row    = inputSPD.GetRow();
+    Int_t index  = npx * column + row;
+
+    if (module >= size) continue;
  
-	last = (modA[module])->GetEntries();
-	TClonesArray& dum = *modA[module];
-	fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
-	thr += 1.;
-	new (dum[last]) AliITSpListItem(-1, -1, module, index, thr);
+    last = (fModA[module])->GetEntries();
+    TClonesArray& dum = *fModA[module];
+    fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
+    thr += 1.;
+    int label = kMaxLabel;
+    if (rawID2clusID) { // RS If the raw->cluster ID is set (filled by cluster finder) store cluster ID's in SDigits
+      if (rawID2clusID->GetSize()<=countRW) {AliError(Form("The buffer of rawSPD to clusSPD ID's is shorter than current rawSPD ID=%d",countRW));}
+      else label = (*rawID2clusID)[countRW];
     }
-    rawReader->Reset();
-
-    //
-    // SDD
-    // 
-    AliITSsegmentationSDD* segSDD = (AliITSsegmentationSDD*) fDetTypeSim->GetSegmentationModel(1);
-    npx = segSDD->Npx();
-    Int_t scalef=AliITSsimulationSDD::ScaleFourier(segSDD);
-    Int_t firstSDD=AliITSgeomTGeo::GetModuleIndex(3,1,1);
-    Int_t firstSSD=AliITSgeomTGeo::GetModuleIndex(5,1,1);
-
-    AliITSRawStream* inputSDD=AliITSRawStreamSDD::CreateRawStreamSDD(rawReader);
-    for(Int_t iMod=firstSDD; iMod<firstSSD; iMod++){
-      AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)fDetTypeSim->GetCalibrationModel(iMod);
-      Bool_t isZeroSupp=cal->GetZeroSupp();
-      if(isZeroSupp){ 
-	for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,cal->GetZSLowThreshold(iSid));
-     }else{
-	for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,0);
-      }
+    new (dum[last]) AliITSpListItem(label, -1, module, index, thr);
+  }
+  rawReader->Reset();
+
+  //
+  // SDD
+  // 
+  AliITSsegmentationSDD* segSDD = (AliITSsegmentationSDD*) fDetTypeSim->GetSegmentationModel(1);
+  npx = segSDD->Npx();
+  Int_t scalef=AliITSsimulationSDD::ScaleFourier(segSDD);
+  Int_t firstSDD=AliITSgeomTGeo::GetModuleIndex(3,1,1);
+  Int_t firstSSD=AliITSgeomTGeo::GetModuleIndex(5,1,1);
+  //
+  countRW = -1; // RS
+  rawID2clusID = fkRawID2ClusID[kSDD];
+  AliITSRawStream* inputSDD=AliITSRawStreamSDD::CreateRawStreamSDD(rawReader);
+  for(Int_t iMod=firstSDD; iMod<firstSSD; iMod++){
+    AliITSCalibrationSDD* cal = (AliITSCalibrationSDD*)fDetTypeSim->GetCalibrationModel(iMod);
+    Bool_t isZeroSupp=cal->GetZeroSupp();
+    if(isZeroSupp){ 
+      for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,cal->GetZSLowThreshold(iSid));
+    }else{
+      for(Int_t iSid=0; iSid<2; iSid++) inputSDD->SetZeroSuppLowThreshold(iMod-firstSDD,iSid,0);
     }
+  }
 
-    AliITSDDLModuleMapSDD* ddlmap=fDetTypeSim->GetDDLModuleMapSDD();
-    inputSDD->SetDDLModuleMap(ddlmap);
-    while(inputSDD->Next()){
-	if(inputSDD->IsCompletedModule()==kFALSE && 
-	   inputSDD->IsCompletedDDL()==kFALSE){
-
-	  Int_t module = inputSDD->GetModuleID();
-	  Int_t anode  = inputSDD->GetCoord1()+segSDD->NpzHalf()*inputSDD->GetChannel();
-	  Int_t time   = inputSDD->GetCoord2();
-	  Int_t signal10 = inputSDD->GetSignal();
-	  Int_t index = AliITSpList::GetIndex(anode,time,scalef*npx);
-
-	  if (module >= size) continue;
-	  last = modA[module]->GetEntries();
-	  TClonesArray& dum = *modA[module];
-	  new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal10));
-	  ((AliITSpListItem*) dum.At(last))->AddSignalAfterElect(module, index, Double_t(signal10));
-	}
+  AliITSDDLModuleMapSDD* ddlmap=fDetTypeSim->GetDDLModuleMapSDD();
+  inputSDD->SetDDLModuleMap(ddlmap);
+  while(inputSDD->Next()){
+    countRW++; // RS
+    if(inputSDD->IsCompletedModule()==kFALSE && 
+       inputSDD->IsCompletedDDL()==kFALSE){
+
+      Int_t module = inputSDD->GetModuleID();
+      Int_t anode  = inputSDD->GetCoord1()+segSDD->NpzHalf()*inputSDD->GetChannel();
+      Int_t time   = inputSDD->GetCoord2();
+      Int_t signal10 = inputSDD->GetSignal();
+      Int_t index = AliITSpList::GetIndex(anode,time,scalef*npx);
+
+      if (module >= size) continue;
+      last = fModA[module]->GetEntries();
+      TClonesArray& dum = *fModA[module];
+      int label = kMaxLabel;
+      if (rawID2clusID) { // RS If the raw->cluster ID is set (filled by cluster finder) store cluster ID's in SDigits
+	if (rawID2clusID->GetSize()<=countRW) {AliError(Form("The buffer of rawSDD to clusSDD ID's is shorter than current rawSDD ID=%d",countRW));}
+	else label = (*rawID2clusID)[countRW];
+      }
+      new (dum[last]) AliITSpListItem(label, -1, module, index, Double_t(signal10));
+      ((AliITSpListItem*) dum.At(last))->AddSignalAfterElect(module, index, Double_t(signal10));
     }
-    delete inputSDD;
-    rawReader->Reset();
+  }
+  delete inputSDD;
+  rawReader->Reset();
     
-    //
-    // SSD
-    // 
-    AliITSsegmentationSSD* segSSD = (AliITSsegmentationSSD*) fDetTypeSim->GetSegmentationModel(2);
-    npx = segSSD->Npx();
-    AliITSRawStreamSSD inputSSD(rawReader);
-    while(1){
-	Bool_t next  = inputSSD.Next();
-	if (!next) break;
-
-	Int_t module  = inputSSD.GetModuleID();
-	Int_t side    = inputSSD.GetSideFlag();
-	Int_t strip   = inputSSD.GetStrip();
-	Int_t signal  = inputSSD.GetSignal();
-	Int_t index  = npx * side + strip;
-
-	if (module >= size) continue;
+  //
+  // SSD
+  // 
+  AliITSsegmentationSSD* segSSD = (AliITSsegmentationSSD*) fDetTypeSim->GetSegmentationModel(2);
+  npx = segSSD->Npx();
+  AliITSRawStreamSSD inputSSD(rawReader);
+  countRW = -1;
+  rawID2clusID = fkRawID2ClusID[kSSD];
+  while(1){
+    Bool_t next  = inputSSD.Next();
+    if (!next) break;
+    countRW++; // RS
+    Int_t module  = inputSSD.GetModuleID();
+    if(module<0)AliError(Form("Invalid SSD  module %d \n",module));
+    if(module<0)continue;
+    Int_t side    = inputSSD.GetSideFlag();
+    Int_t strip   = inputSSD.GetStrip();
+    Int_t signal  = inputSSD.GetSignal();
+    Int_t index  = npx * side + strip;
+
+    if (module >= size) continue;
 	
-	last = modA[module]->GetEntries();
-	TClonesArray& dum = *modA[module];
-	new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal));
-    }
-    rawReader->Reset();
-    AliITSpListItem* sdig = 0;
+    last = fModA[module]->GetEntries();
+    TClonesArray& dum = *fModA[module];
+    int label = kMaxLabel;
+    if (rawID2clusID) { // RS If the raw->cluster ID is set (filled by cluster finder) store cluster ID's in SDigits
+      if (rawID2clusID->GetSize()<=countRW) {AliError(Form("The buffer of rawSSD to clusSSD ID's is shorter than current rawSSD ID=%d",countRW));}
+      else label = (*rawID2clusID)[countRW];
+    }    
+    new (dum[last]) AliITSpListItem(label, -1, module, index, Double_t(signal));
+  }
+  rawReader->Reset();
+  AliITSpListItem* sdig = 0;
     
-    Int_t firstssd = GetITSgeom()->GetStartDet(kSSD);
-    Double_t adcToEv = 1.;
-    for (Int_t mod = 0; mod < size; mod++)
-      {
+  Int_t firstssd = GetITSgeom()->GetStartDet(kSSD);
+  Double_t adcToEv = 1.;
+  for (Int_t mod = 0; mod < size; mod++)
+    {
       if(mod>=firstssd) {
 	AliITSCalibrationSSD* calssd = (AliITSCalibrationSSD*)fDetTypeSim->GetCalibrationModel(mod);
 	adcToEv = 1./calssd->GetSSDDEvToADC(1.);
       }
-      Int_t nsdig =  modA[mod]->GetEntries();
+      Int_t nsdig =  fModA[mod]->GetEntries();
       for (Int_t ie = 0; ie < nsdig; ie++) {
-	sdig = (AliITSpListItem*) (modA[mod]->At(ie));
-	Int_t digsig = sdig->GetSignal();
+	sdig = (AliITSpListItem*) (fModA[mod]->At(ie));
+      	Double_t digsig = sdig->GetSignal();
 	if(mod>=firstssd) digsig*=adcToEv; // for SSD: convert back charge from ADC to electron
-	new (aSDigits[ie]) AliITSpListItem(-1, -1, mod, sdig->GetIndex(), digsig);
-	    Float_t sig = sdig->GetSignalAfterElect();
-	    if(mod>=firstssd) sig*=adcToEv;
-	    if (sig > 0.) {
-		sdig = (AliITSpListItem*)aSDigits[ie];
-		sdig->AddSignalAfterElect(mod, sdig->GetIndex(), Double_t(sig));
-	    }
+	new (aSDigits[ie]) AliITSpListItem(sdig->GetTrack(0), -1, mod, sdig->GetIndex(), digsig);
+	Float_t sig = sdig->GetSignalAfterElect();
+	if(mod>=firstssd) sig*=adcToEv;
+	if (sig > 0.) {
+	  sdig = (AliITSpListItem*)aSDigits[ie];
+	  sdig->AddSignalAfterElect(mod, sdig->GetIndex(), Double_t(sig));
 	}
+      }
 	
-	tree->Fill();
-	aSDigits.Clear();
-	modA[mod]->Clear();
+      tree->Fill();
+      aSDigits.Clear();
+      fModA[mod]->Clear();
     }
-    loader->WriteSDigits("OVERWRITE");    
-    delete modA;
-    return kTRUE;
+  loader->WriteSDigits("OVERWRITE");    
+  return kTRUE;
 }
 
-
 //______________________________________________________________________
 void AliITS::UpdateInternalGeometry(){
-
   //reads new geometry from TGeo 
 //   AliDebug(1,"Delete ITSgeom and create a new one reading TGeo");
 
   AliITSVersion_t version = (AliITSVersion_t)IsVersion();
   Int_t minor = 0;
-  if(version==kvPPRasymmFMD) minor=2;  // default minor version for this geom.
   AliITSInitGeometry initgeom;
   AliITSgeom* geom = initgeom.CreateAliITSgeom(version,minor);
   SetITSgeom(geom);
@@ -1369,3 +1408,13 @@ AliTriggerDetector* AliITS::CreateTriggerDetector() const {
   // create an AliITSTrigger object (and set trigger conditions as input)
   return new AliITSTrigger(fDetTypeSim->GetTriggerConditions());
 }
+//______________________________________________________________________
+void AliITS::WriteFOSignals(){
+// This method write FO signals in Digits tree both in Hits2Digits
+// or SDigits2Digits
+
+  fDetTypeSim->ProcessNoiseForFastOr();
+  fDetTypeSim->WriteFOSignals();
+}
+
+