#include <TString.h>
#include <TTree.h>
#include <TVirtualMC.h>
+#include <TArrayI.h>
#include "AliDetector.h"
#include "AliITS.h"
#include "AliITSDetTypeSim.h"
#include "AliITSsimulation.h"
#include "AliITSsimulationFastPoints.h"
#include "AliMC.h"
+#include "AliITSDigitizer.h"
#include "AliITSRecPoint.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSDD.h"
// 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):
//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):
//PH SetMarkerColor(kRed);
if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
-
+ for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
}
//______________________________________________________________________
AliITS::~AliITS(){
}
}
+//______________________________________________________________________
+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:
+ // AliDigitizationInput* digInput The Manger class for Digitization
+ // Output:
+ // none.
+ // Return:
+ // A new AliITSRunDigitizer (cast as a AliDigitizer).
+
+ return new AliITSDigitizer(digInput);
+}
//______________________________________________________________________
void AliITS::Init(){
// Initializer ITS after it has been built
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();
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));
(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);
}
//______________________________________________________________________
-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.
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);
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);
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
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);
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();
AliError("fDetTypeSim is 0!");
return;
}
-
const char *all = strstr(opt,"All");
const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),
strstr(opt,"SSD")};
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();
}
}
}
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();
TClonesArray& dum = *fModA[module];
fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
thr += 1.;
- new (dum[last]) AliITSpListItem(-1, -1, module, index, thr);
+ 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];
+ }
+ new (dum[last]) AliITSpListItem(label, -1, module, index, thr);
}
rawReader->Reset();
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);
AliITSDDLModuleMapSDD* ddlmap=fDetTypeSim->GetDDLModuleMapSDD();
inputSDD->SetDDLModuleMap(ddlmap);
while(inputSDD->Next()){
+ countRW++; // RS
if(inputSDD->IsCompletedModule()==kFALSE &&
inputSDD->IsCompletedDDL()==kFALSE){
if (module >= size) continue;
last = fModA[module]->GetEntries();
TClonesArray& dum = *fModA[module];
- new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal10));
+ 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));
}
}
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;
last = fModA[module]->GetEntries();
TClonesArray& dum = *fModA[module];
- new (dum[last]) AliITSpListItem(-1, -1, module, index, Double_t(signal));
+ 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;
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);
+ 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.) {
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);
// 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();
+}
+
+