/*
<img src="picts/ITS/ITS_Analysis_schema.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>Roberto Barbera is in charge of the ITS Offline code (1999).
<a href="mailto:roberto.barbera@ct.infn.it">Roberto Barbera</a>.
</font>
<pre>
*/
//End_Html
/*
<img src="picts/ITS/AliITS_Class_Diagram.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>This show the class diagram of the different elements that are part of
the AliITS class.
</font>
<pre>
*/
//End_Html
#include <stdlib.h>
#include <TClonesArray.h>
#include <TFile.h>
#include <TParticle.h>
#include <TString.h>
#include <TTree.h>
#include <TVirtualMC.h>
#include <TArrayI.h>
#include "AliDetector.h"
#include "AliITS.h"
#include "AliITSDetTypeSim.h"
#include "AliITSDDLRawData.h"
#include "AliITSLoader.h"
#include "AliITShit.h"
#include "AliITSmodule.h"
#include "AliITSpListItem.h"
#include "AliITSsimulation.h"
#include "AliITSsimulationFastPoints.h"
#include "AliMC.h"
#include "AliITSDigitizer.h"
#include "AliITSRecPoint.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSDD.h"
#include "AliITSsimulationSDD.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSCalibrationSSD.h"
#include "AliITSsegmentationSSD.h"
#include "AliITSRawStreamSPD.h"
#include "AliITSRawStreamSSD.h"
#include "AliITSRawStreamSDD.h"
#include "AliRawReader.h"
#include "AliRun.h"
#include "AliLog.h"
#include "AliITSInitGeometry.h"
#include "AliITSFOSignalsSPD.h"
ClassImp(AliITS)
AliITS::AliITS() : AliDetector(),
fDetTypeSim(0),
fEuclidOut(0),
fOpt("All"),
fIdN(0),
fIdSens(0),
fIdName(0),
fITSmodules(0),
fTiming(kFALSE),
fSimuParam(0),
fModA(0),
fpSDigits(0)
{
for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
}
AliITS::AliITS(const Char_t *title):
AliDetector("ITS",title),
fDetTypeSim(0),
fEuclidOut(0),
fOpt("All"),
fIdN(0),
fIdSens(0),
fIdName(0),
fITSmodules(0),
fTiming(kFALSE),
fSimuParam(0),
fModA(0),
fpSDigits(0)
{
fHits = new TClonesArray("AliITShit",1560);
if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
SetDetectors();
fDetTypeSim = new AliITSDetTypeSim();
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):
AliDetector(name,title),
fDetTypeSim(0),
fEuclidOut(0),
fOpt("All"),
fIdN(0),
fIdSens(0),
fIdName(0),
fITSmodules(0),
fTiming(kFALSE),
fSimuParam(0),
fModA(0),
fpSDigits(0)
{
fHits = new TClonesArray("AliITShit",1560);
if(gAlice->GetMCApp()) gAlice->GetMCApp()->AddHitList(fHits);
SetDetectors();
fDetTypeSim = new AliITSDetTypeSim();
if(!fLoader) MakeLoader(AliConfig::GetDefaultEventFolderName());
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
for (int i=fgkNTYPES;i--;) fkRawID2ClusID[i] = 0;
}
AliITS::~AliITS(){
if (fHits) {
fHits->Delete();
delete fHits;
fHits=0;
}
if(fITSmodules) {
this->ClearModules();
delete fITSmodules;
fITSmodules = 0;
}
delete[] fIdName;
delete[] fIdSens;
Int_t size = AliITSgeomTGeo::GetNModules();
if (fDetTypeSim){
delete fDetTypeSim;
fDetTypeSim = 0;
}
if(fSimuParam){
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(AliDigitizationInput* digInput)const{
return new AliITSDigitizer(digInput);
}
void AliITS::Init(){
Int_t i;
if(TVirtualMC::GetMC()) for(i=0;i<fIdN;i++) fIdSens[i] = TVirtualMC::GetMC()->VolId(fIdName[i]);
}
void AliITS::SetDefaults(){
AliInfoClass("AliITS::Setting Defaults");
if(!fDetTypeSim) {
Error("SetDefaults()","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetDefaults();
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
}
void AliITS::SetDefaultSimulation(){
if(!fDetTypeSim) {
Error("SetDefaultSimulation()","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetDefaultSimulation();
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
}
void AliITS::MakeBranch(Option_t* option){
if(!fDetTypeSim) {
Error("MakeBranch","fDetTypeSim is 0!");
return;
}
Bool_t cH = (strstr(option,"H")!=0);
Bool_t cS = (strstr(option,"S")!=0);
Bool_t cD = (strstr(option,"D")!=0);
if(cH && (fHits == 0x0)) fHits = new TClonesArray("AliITShit", 1560);
AliDetector::MakeBranch(option);
if(cS) MakeBranchS(0);
if(cD) MakeBranchD(0);
}
void AliITS::MakeBranchS(const char* fl){
if(!fDetTypeSim){
Error("MakeBranchS","fDetTypeSim is 0!");
}
Int_t buffersize = 4000;
char branchname[31];
snprintf(branchname,30,"%s",GetName());
if(fLoader->TreeS()){
TClonesArray* sdig = (TClonesArray*)fDetTypeSim->GetSDigits();
MakeBranchInTree(fLoader->TreeS(),branchname,&sdig,buffersize,fl);
}
}
void AliITS::MakeBranchD(const char* file){
if(!fDetTypeSim) {
Warning("MakeBranchD","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
MakeBranchInTreeD(fLoader->TreeD(),file);
}
void AliITS:: MakeBranchInTreeD(TTree* treeD, const char* file){
if(!fDetTypeSim){
Error("MakeBranchS","fDetTypeSim is 0!");
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
const Char_t *det[3] = {"SPD","SDD","SSD"};
const Char_t* digclass;
Int_t buffersize = 4000;
Char_t branchname[31];
if(!fDetTypeSim->GetDigits()){
fDetTypeSim->SetDigits(new TObjArray(fgkNTYPES));
}
for(Int_t i=0;i<fgkNTYPES;i++){
digclass = fDetTypeSim->GetDigitClassName(i);
TString classn = digclass;
if(!((fDetTypeSim->GetDigits())->At(i))){
(fDetTypeSim->GetDigits())->AddAt(new TClonesArray(classn.Data(),1000),i);
}
else ResetDigits(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::SetTreeAddress(){
if(!fDetTypeSim) {
Error("SetTreeAddress","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
TTree *treeS = fLoader->TreeS();
TTree *treeD = fLoader->TreeD();
if (fLoader->TreeH() && (fHits == 0x0)) {
fHits = new TClonesArray("AliITShit", 1560);
}
AliDetector::SetTreeAddress();
fDetTypeSim->SetTreeAddressS(treeS, (Char_t*)GetName());
fDetTypeSim->SetTreeAddressD(treeD, (Char_t*)GetName());
}
void AliITS::AddHit(Int_t track, Int_t *vol, Float_t *hits){
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliITShit(fIshunt,track,vol,hits);
}
void AliITS::FillModules(Int_t ,Int_t bgrev,Int_t ,
Option_t *option, const char *filename){
static TTree *trH1;
static Bool_t first=kTRUE;
static TFile *file;
const char *addBgr = strstr(option,"Add");
if (addBgr ) {
if(first) {
file=new TFile(filename);
}
first=kFALSE;
file->cd();
file->ls();
if(trH1) delete trH1;
trH1=0;
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(fLoader->TreeH(),0);
if (addBgr ) {
FillModules(trH1,10000000);
TTree *fAli=fLoader->GetRunLoader()->TreeK();
TFile *fileAli=0;
if (fAli) {
fileAli =fAli->GetCurrentFile();
fileAli->cd();
}
}
}
void AliITS::FillModules(TTree *treeH, Int_t mask) {
if (treeH == 0x0)
{
AliError("Tree H is NULL");
return;
}
Int_t lay,lad,det,index;
AliITShit *itsHit=0;
AliITSmodule *mod=0;
char branchname[21];
snprintf(branchname,20,"%s",GetName());
TBranch *branch = treeH->GetBranch(branchname);
if (!branch) {
Error("FillModules","%s branch in TreeH not found",branchname);
return;
}
branch->SetAddress(&fHits);
Int_t nTracks =(Int_t) treeH->GetEntries();
Int_t iPrimTrack,h;
for(iPrimTrack=0; iPrimTrack<nTracks; iPrimTrack++){
ResetHits();
Int_t nBytes = treeH->GetEvent(iPrimTrack);
if (nBytes <= 0) continue;
Int_t nHits = fHits->GetEntriesFast();
for(h=0; h<nHits; h++){
itsHit = (AliITShit *)fHits->UncheckedAt(h);
itsHit->GetDetectorID(lay,lad,det);
if (GetITSgeom()) {
index = GetITSgeom()->GetModuleIndex(lay,lad,det);
} else {
index=det-1;
}
mod = GetModule(index);
itsHit->SetTrack(itsHit->GetTrack()+mask);
mod->AddHit(itsHit,iPrimTrack,h);
}
}
}
Bool_t AliITS::InitModules(Int_t size,Int_t &nmodules){
if(fITSmodules){
fITSmodules->Delete();
delete fITSmodules;
}
if(!fDetTypeSim) {
Error("InitModules","fDetTypeSim is null!");
return kFALSE;
}
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
Int_t nl,indexMAX,index;
if(size<=0){
if(fDetTypeSim->GetITSgeom()==0) {
Error("InitModules","fITSgeom not defined");
return kFALSE;
}
nl = fDetTypeSim->GetITSgeom()->GetNlayers();
indexMAX = fDetTypeSim->GetITSgeom()->GetIndexMax();
nmodules = indexMAX;
fITSmodules = new TObjArray(indexMAX);
for(index=0;index<indexMAX;index++){
fITSmodules->AddAt( new AliITSmodule(index),index);
}
}else{
fITSmodules = new TObjArray(size);
for(index=0;index<size;index++) {
fITSmodules->AddAt( new AliITSmodule(index),index);
}
nmodules = size;
}
return kTRUE;
}
void AliITS::Hits2SDigits(){
if(!fDetTypeSim) {
Error("Hits2SDigits","fDetTypeSim is null!");
return;
}
SetDefaults();
fLoader->LoadHits("read");
fLoader->LoadSDigits("recreate");
AliRunLoader* rl = fLoader->GetRunLoader();
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
rl->GetEvent(iEvent);
if (!fLoader->TreeS()) fLoader->MakeTree("S");
MakeBranch("S");
SetTreeAddress();
HitsToPreDigits(iEvent,0,-1," ",fOpt," ");
}
fLoader->UnloadHits();
fLoader->UnloadSDigits();
}
void AliITS::Hits2Digits(){
if(!fDetTypeSim) {
Error("Hits2SDigits","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
SetDefaults();
fLoader->LoadHits("read");
fLoader->LoadDigits("recreate");
AliRunLoader* rl = fLoader->GetRunLoader();
for (Int_t iEvent = 0; iEvent < rl->GetNumberOfEvents(); iEvent++) {
rl->GetEvent(iEvent);
if (!fLoader->TreeD()) fLoader->MakeTree("D");
MakeBranch("D");
SetTreeAddress();
HitsToDigits(iEvent,0,-1," ",fOpt," ");
}
fLoader->UnloadHits();
fLoader->UnloadDigits();
}
void AliITS::HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
Option_t *option,Option_t *opt,
const char *filename){
if(!fDetTypeSim) {
Error("HitsToDigits","fDetTypeSim is null!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
if(!GetITSgeom()) return;
AliITSgeom *geom = GetITSgeom();
const char *all = strstr(opt,"All");
const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
strstr(opt,"SSD")};
static Bool_t setDef=kTRUE;
if (setDef) SetDefaultSimulation();
setDef=kFALSE;
Int_t nmodules;
InitModules(size,nmodules);
FillModules(evNumber,bgrev,nmodules,option,filename);
fDetTypeSim->ResetFOSignals();
AliITSsimulation *sim = 0;
AliITSmodule *mod = 0;
Int_t id;
for(Int_t module=0;module<geom->GetIndexMax();module++){
id = geom->GetModuleType(module);
if (!all && !det[id]) continue;
sim = (AliITSsimulation*)fDetTypeSim->GetSimulationModel(id);
if (!sim) {
Error("HitsToDigits","The simulation class was not "
"instanciated for module %d type %s!",module,
geom->GetModuleTypeName(module));
exit(1);
}
mod = (AliITSmodule *)fITSmodules->At(module);
sim->DigitiseModule(mod,module,evNumber);
fLoader->TreeD()->Fill();
ResetDigits();
}
ClearModules();
if (all || det[0]) {
WriteFOSignals();
}
fLoader->TreeD()->GetEntries();
fLoader->TreeD()->AutoSave();
fLoader->TreeD()->Reset();
}
void AliITS::Hits2PreDigits(){
if(!fDetTypeSim) {
Error("Hits2SDigits","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
SetDefaults();
HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
0,-1," ",fOpt," ");
}
void AliITS::HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
Option_t *option,Option_t *opt,
const char *filename){
if(!fDetTypeSim) {
Error("HitsToPreDigits","fDetTypeSim is null!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
if(!GetITSgeom()){
Error("HitsToPreDigits","fGeom is null!");
return;
}
AliITSgeom *geom = GetITSgeom();
const char *all = strstr(opt,"All");
const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
strstr(opt,"SSD")};
static Bool_t setDef=kTRUE;
if (setDef) SetDefaultSimulation();
setDef=kFALSE;
Int_t nmodules;
InitModules(size,nmodules);
FillModules(evNumber,bgrev,nmodules,option,filename);
AliITSsimulation *sim = 0;
AliITSmodule *mod = 0;
Int_t id,module;
for(module=0;module<geom->GetIndexMax();module++){
id = geom->GetModuleType(module);
if (!all && !det[id]) continue;
sim = (AliITSsimulation*)GetSimulationModel(id);
if (!sim) {
Error("HitsToPreDigits","The simulation class was not "
"instanciated for module %d type %s!",module,
geom->GetModuleTypeName(module));
exit(1);
}
mod = (AliITSmodule *)fITSmodules->At(module);
sim->SDigitiseModule(mod,module,evNumber);
fLoader->TreeS()->Fill();
fDetTypeSim->ResetSDigits();
}
ClearModules();
fLoader->TreeS()->GetEntries();
fLoader->TreeS()->AutoSave();
fLoader->WriteSDigits("OVERWRITE");
fLoader->TreeS()->Reset();
}
void AliITS::HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
Option_t *opt0,Option_t *opt1,
const char *flnm){
if(!GetITSgeom()){
Error("HitsToPreDigits","fGeom is null!");
return;
}
AliITSgeom *geom = GetITSgeom();
AliITSLoader *pITSloader = (AliITSLoader*)fLoader;
const char *all = strstr(opt1,"All");
const char *det[3] ={strstr(opt1,"SPD"),strstr(opt1,"SDD"),
strstr(opt1,"SSD")};
Int_t nmodules;
InitModules(size,nmodules);
FillModules(evNumber,bgrev,nmodules,opt0,flnm);
AliITSsimulation *sim = 0;
AliITSmodule *mod = 0;
Int_t id,module;
TTree *lTR = pITSloader->TreeR();
if(!lTR) {
pITSloader->MakeTree("R");
lTR = pITSloader->TreeR();
}
TClonesArray* ptarray = new TClonesArray("AliITSRecPoint",1000);
TBranch* branch = (TBranch*)lTR->Branch("ITSRecPointsF",&ptarray);
branch->SetAddress(&ptarray);
for(module=0;module<geom->GetIndexMax();module++){
id = geom->GetModuleType(module);
if (!all && !det[id]) continue;
sim = (AliITSsimulation*)GetSimulationModel(id);
if (!sim) {
Error("HitsToFastPoints","The simulation class was not "
"instantiated for module %d type %s!",module,
geom->GetModuleTypeName(module));
exit(1);
}
mod = (AliITSmodule *)fITSmodules->At(module);
sim->CreateFastRecPoints(mod,module,gRandom,ptarray);
lTR->Fill();
ptarray->Clear();
}
ClearModules();
fLoader->WriteRecPoints("OVERWRITE");
delete ptarray;
}
Int_t AliITS::Hits2Clusters(TTree *hTree, TTree *cTree) {
if(!GetITSgeom()){
Error("HitsToPreDigits","fGeom is null!");
return 1;
}
AliITSgeom *geom=GetITSgeom();
Int_t mmax=geom->GetIndexMax();
InitModules(-1,mmax);
FillModules(hTree,0);
TClonesArray *points = new TClonesArray("AliITSRecPoint",1000);
TBranch *branch=cTree->GetBranch("ITSRecPoints");
if (!branch) cTree->Branch("ITSRecPoints",&points);
else branch->SetAddress(&points);
AliITSsimulationFastPoints sim;
Int_t ncl=0;
for (Int_t m=0; m<mmax; m++) {
AliITSmodule *mod=GetModule(m);
sim.CreateFastRecPoints(mod,m,gRandom,points);
ncl+=points->GetEntriesFast();
cTree->Fill();
points->Clear();
}
AliDebug(1,Form("Number of found fast clusters : %d",ncl));
delete points;
return 0;
}
void AliITS::CheckLabels(Int_t lab[3]) const {
if(lab[0]<0 && lab[1]<0 && lab[2]<0) return;
Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
for (Int_t i=0;i<3;i++){
Int_t label = lab[i];
if (label>=0 && label<ntracks) {
TParticle *part=(TParticle*)gAlice->GetMCApp()->Particle(label);
if (part->P() < 0.005) {
Int_t m=part->GetFirstMother();
if (m<0) {
continue;
}
if (part->GetStatusCode()>0) {
continue;
}
lab[i]=m;
}
}
}
}
void AliITS::SDigitsToDigits(Option_t *opt){
if (!fDetTypeSim) {
AliError("fDetTypeSim is 0!");
return;
}
const char *all = strstr(opt,"All");
const char *det[3] ={strstr(opt,"SPD"),strstr(opt,"SDD"),
strstr(opt,"SSD")};
fDetTypeSim->ResetFOSignals();
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
SetDefaults();
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
fDetTypeSim->SDigitsToDigits(opt,(Char_t*)GetName());
if (all || det[0]) {
WriteFOSignals();
}
}
void AliITS::ResetDigits(){
if(!fDetTypeSim) {
Error("ResetDigits","fDetTypeSim is 0!");
return;
}
fDetTypeSim->ResetDigits();
}
void AliITS::ResetDigits(Int_t branch){
if(!fDetTypeSim) {
Error("ResetDigits","fDetTypeSim is 0!");
return;
}
fDetTypeSim->ResetDigits(branch);
}
void AliITS::AddSumDigit(AliITSpListItem &sdig){
if(!fDetTypeSim) {
Error("AddSumDigit","fDetTypeSim is 0!");
return;
}
fDetTypeSim->AddSumDigit(sdig);
}
void AliITS::AddSimDigit(Int_t branch, AliITSdigit *d){
if(!fDetTypeSim) {
Error("AddSimDigit","fDetTypeSim is 0!");
return;
}
fDetTypeSim->AddSimDigit(branch,d);
}
void AliITS::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,Int_t *tracks,
Int_t *hits,Float_t *charges, Int_t sigexpanded){
if(!fDetTypeSim) {
Error("AddSimDigit","fDetTypeSim is 0!");
return;
}
fDetTypeSim->AddSimDigit(branch,phys,digits,tracks,hits,charges,sigexpanded);
}
void AliITS::Digits2Raw(){
if(!fDetTypeSim) {
Error("Digits2Raw","fDetTypeSim is 0!");
return;
}
fDetTypeSim->SetLoader((AliITSLoader*)fLoader);
SetDefaults();
if(fSimuParam) fDetTypeSim->SetSimuParam(fSimuParam);
fDetTypeSim->GetLoader()->LoadDigits();
TTree* digits = fDetTypeSim->GetLoader()->TreeD();
if (!digits) {
Error("Digits2Raw", "no digits tree");
return;
}
fDetTypeSim->SetTreeAddressD(digits,(Char_t*)GetName());
AliITSFOSignalsSPD* foSignals = NULL;
AliRunLoader* runLoader = AliRunLoader::Instance();
AliITSLoader* itsLoader = (AliITSLoader*) runLoader->GetLoader("ITSLoader");
if (!itsLoader) {
AliError("ITS loader is NULL.");
}
else {
if(!itsLoader->TreeD()) AliError(" !!! No TreeD available !!!");
foSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
if(!foSignals) AliError("FO signals not retrieved");
}
Bool_t deleteFOsignalsLater = kFALSE;
if (!foSignals) {
AliError("FO signals not available. No FO bits will be written.");
foSignals = new AliITSFOSignalsSPD();
deleteFOsignalsLater = kTRUE;
}
AliITSDDLModuleMapSDD* ddlsdd=fDetTypeSim->GetDDLModuleMapSDD();
Char_t rawSDD=fDetTypeSim->GetSimuParam()->GetSDDRawDataFormat();
AliITSDDLRawData rawWriter;
rawWriter.SetSDDRawFormat(rawSDD);
rawWriter.SetVerbose(0);
AliDebug(1,"Formatting raw data for SPD");
rawWriter.RawDataSPD(digits->GetBranch("ITSDigitsSPD"),foSignals);
if(deleteFOsignalsLater) delete foSignals;
AliDebug(1,Form("Formatting raw data for SDD - Format code =%d",rawSDD));
rawWriter.RawDataSDD(digits->GetBranch("ITSDigitsSDD"),ddlsdd);
AliDebug(1,"Formatting raw data for SSD");
rawWriter.RawDataSSD(digits->GetBranch("ITSDigitsSSD"));
fLoader->UnloadDigits();
}
AliLoader* AliITS::MakeLoader(const char* topfoldername){
AliDebug(1,Form("Creating AliITSLoader. Top folder is %s.",
topfoldername));
fLoader = new AliITSLoader(GetName(),topfoldername);
return fLoader;
}
Bool_t AliITS::Raw2SDigits(AliRawReader* rawReader)
{
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;
tree = loader->TreeS();
if (!tree){
loader->MakeTree("S");
tree = loader->TreeS();
}
if(!fpSDigits){
fpSDigits = new TClonesArray("AliITSpListItem",10000);
}
TClonesArray& aSDigits = *fpSDigits;
Int_t bufsize = 32000;
tree->Branch("ITS", &fpSDigits, bufsize);
Int_t npx = 0;
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;
const TArrayI* rawID2clusID = fkRawID2ClusID[kSPD];
AliITSRawStreamSPD inputSPD(rawReader);
while(1){
Bool_t next = inputSPD.Next();
if (!next) break;
countRW++;
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 = (fModA[module])->GetEntries();
TClonesArray& dum = *fModA[module];
fDetTypeSim->GetSimuParam()->SPDThresholds(module,thr,sigma);
thr += 1.;
int label = kMaxLabel;
if (rawID2clusID) {
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();
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;
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()){
countRW++;
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) {
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();
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++;
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 = fModA[module]->GetEntries();
TClonesArray& dum = *fModA[module];
int label = kMaxLabel;
if (rawID2clusID) {
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++)
{
if(mod>=firstssd) {
AliITSCalibrationSSD* calssd = (AliITSCalibrationSSD*)fDetTypeSim->GetCalibrationModel(mod);
adcToEv = 1./calssd->GetSSDDEvToADC(1.);
}
Int_t nsdig = fModA[mod]->GetEntries();
for (Int_t ie = 0; ie < nsdig; ie++) {
sdig = (AliITSpListItem*) (fModA[mod]->At(ie));
Double_t digsig = sdig->GetSignal();
if(mod>=firstssd) digsig*=adcToEv;
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();
fModA[mod]->Clear();
}
loader->WriteSDigits("OVERWRITE");
return kTRUE;
}
void AliITS::UpdateInternalGeometry(){
AliITSVersion_t version = (AliITSVersion_t)IsVersion();
AliITSInitGeometry initgeom;
AliITSgeom* geom = initgeom.CreateAliITSgeom(version);
SetITSgeom(geom);
}
AliTriggerDetector* AliITS::CreateTriggerDetector() const {
return new AliITSTrigger(fDetTypeSim->GetTriggerConditions());
}
void AliITS::WriteFOSignals(){
fDetTypeSim->ProcessNoiseForFastOr();
fDetTypeSim->WriteFOSignals();
}