[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSDetTypeSimUpg.cxx

/***************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
 $Id: AliITSDetTypeSimUpg.cxx 56993 2012-06-08 08:24:17Z fca $
*/


/////////////////////////////////////////////////////////////////////
// Base simulation functions for ITS upgrade                       //
//                                                                 //
//                                                                 //
/////////////////////////////////////////////////////////////////////          
#include "TBranch.h"
#include "TClonesArray.h"
#include "TObjArray.h"
#include "TTree.h"

#include "AliRun.h"

#include "AliCDBManager.h"
#include "AliCDBId.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliCDBMetaData.h"
#include "AliITSdigit.h"
#include "AliITSdigitPixUpg.h"
#include "AliITSgeom.h"
#include "AliITSDetTypeSimUpg.h"
#include "AliITSpListItem.h"
#include "AliITSCalibration.h"
#include "AliITSsimulation.h"
#include "AliITSTriggerConditions.h"
#include "AliITSsegmentation.h"
#include "AliITSsegmentationPixUpg.h"
#include "AliBaseLoader.h"

using std::endl;
using std::cout;
ClassImp(AliITSDetTypeSimUpg)

const char* AliITSDetTypeSimUpg::fgkDetTypeName[AliITSDetTypeSimUpg::kNDetTypes] = {"PixUpg"};


//----------------------------------------------------------------------
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)
{ 
  // Default Constructor
  // Inputs:
  //    none.
  // Outputs:
  //    none.
  // Return:
  //    A properly zero-ed AliITSDetTypeSimUpg class.
  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));
}

//_______________________________________________________________________
void AliITSDetTypeSimUpg::SetDefaultSegmentation(Int_t idet)
{
  // Set default segmentation model objects
  AliITSsegmentation *seg;
  //  
  if(fSegmentation==0x0){
    fSegmentation = new TObjArray(kNDetTypes);
    fSegmentation->SetOwner(kTRUE);
  }
  if (GetSegmentationModel(idet)) delete (AliITSsegmentation*)fSegmentation->RemoveAt(idet);
  //
  switch (idet) 
    {
    case kDetPixUpg: seg = new AliITSsegmentationPixUpg(); break;
    default        : AliFatal(Form("Uknown detector type %d",idet));
  };
  SetSegmentationModel(idet,seg);
  //
}

//______________________________________________________________________
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; 
  }
  return (AliITSCalibration*)fCalibration->At(iMod);
}

//_______________________________________________________________________
void AliITSDetTypeSimUpg::SetDefaults()
{
  //Set defaults for segmentation and response
  
  if(GetITSgeom()==0){
    Warning("SetDefaults","GetITSgeom() is 0!");
    return;
  } // end if
  if (fCalibration==0) {
    CreateCalibrationArray();
  } // end if
  
  ResetSegmentation();
  if(!GetCalibration()){AliFatal("Exit"); exit(0);}
  
  SetDigitClassName(0,"AliITSdigitPixUpg");
  //  
  for(Int_t idet=0;idet<kNDetTypes;idet++){
    if(!GetSegmentationModel(idet)) SetDefaultSegmentation(idet);
  }
  //
}

//______________________________________________________________________
Bool_t AliITSDetTypeSimUpg::GetCalibration() {
  // Get Default calibration if a storage is not defined.

  if(!fFirstcall){
    AliITSCalibration* cal = GetCalibrationModel(0);
    if(cal)return kTRUE;
  }
  else {
    fFirstcall = kFALSE;
  }
  
  SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
  Int_t run=GetRunNumber();
  
  Bool_t isCacheActive = kTRUE;
  if (run) {
    isCacheActive=kFALSE;
    fCalibration->SetOwner(kTRUE);
  }
  else{
    fCalibration->SetOwner(kFALSE);
  }
  
  AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
  //
  // TO DO, RS
  return kTRUE;
}

//_______________________________________________________________________
void AliITSDetTypeSimUpg::SetDefaultSimulation()
{
  //Set default simulation for detector type
  //
  if (GetITSgeom()==0) {
    Warning("SetDefaultSimulation","GetITSgeom() is 0!");
    return;
  }
  if (fCalibration==0) {
    Warning("SetDefaultSimulation","fCalibration is 0!");
    return;
  }
  if (fSegmentation==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)){
	Warning("SetDefaultSimulation",
		"Segmentation not defined for det %d - Default taken\n!",i);
	SetDefaultSegmentation(i);
      }
  //
  AliITSsimulation* sim;
  //
  for (Int_t idet=0;idet<kNDetTypes;idet++) {
    //OixUpg
    if(idet==0){
      sim = GetSimulationModel(idet); 
      if(!sim){
	sim = new AliITSsimulationPixUpg(this);
	SetSimulationModel(idet,sim);
      }
    }
  }
}

//___________________________________________________________________
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));
  switch(branch){
  case kDetPixUpg:
    new(ldigits[fNDigits[branch]++]) AliITSdigitPixUpg(*((AliITSdigitPixUpg*)d));
    break;
  default:
    AliFatal(Form("Digit for unknown detector type %d",branch));
  }  
}

//______________________________________________________________________
void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
				      Int_t *tracks,Int_t *hits,Float_t *charges, 
				      Int_t sigexpanded)
{
  //   Add a simulated digit to the list.

  TClonesArray &ldigits = *((TClonesArray*)fDigits->At(branch));
  switch(branch){
  case kDetPixUpg:
    new(ldigits[fNDigits[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;
}
Commit	Line	Data
a84c4b15	1	/***************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	$Id: AliITSDetTypeSimUpg.cxx 56993 2012-06-08 08:24:17Z fca $
	18	*/
	19
	20
	21	/////////////////////////////////////////////////////////////////////
	22	// Base simulation functions for ITS upgrade //
	23	// //
	24	// //
	25	/////////////////////////////////////////////////////////////////////
	26	#include "TBranch.h"
	27	#include "TClonesArray.h"
	28	#include "TObjArray.h"
	29	#include "TTree.h"
	30
	31	#include "AliRun.h"
	32
	33	#include "AliCDBManager.h"
	34	#include "AliCDBId.h"
	35	#include "AliCDBStorage.h"
	36	#include "AliCDBEntry.h"
	37	#include "AliCDBMetaData.h"
	38	#include "AliITSdigit.h"
	39	#include "AliITSdigitPixUpg.h"
	40	#include "AliITSgeom.h"
	41	#include "AliITSDetTypeSimUpg.h"
	42	#include "AliITSpListItem.h"
	43	#include "AliITSCalibration.h"
	44	#include "AliITSsimulation.h"
	45	#include "AliITSTriggerConditions.h"
	46	#include "AliITSsegmentation.h"
	47	#include "AliITSsegmentationPixUpg.h"
	48	#include "AliBaseLoader.h"
	49
	50	using std::endl;
	51	using std::cout;
	52	ClassImp(AliITSDetTypeSimUpg)
	53
	54	const char* AliITSDetTypeSimUpg::fgkDetTypeName[AliITSDetTypeSimUpg::kNDetTypes] = {"PixUpg"};
	55
	56
	57	//----------------------------------------------------------------------
	58	AliITSDetTypeSimUpg::AliITSDetTypeSimUpg():
	59	TObject(),
	60	fSimulation(), // [NDet]
	61	fSegmentation(), // [NDet]
	62	fCalibration(), // [NMod]
	63	fNSDigits(0), //! number of SDigits
	64	fSDigits("AliITSpListItem",1000),
65	fNDigits(0), //! number of Digits
66	fRunNumber(0), //! Run number (to access DB)
67	fDigits(), //! [NMod][NDigits]
68	fSimuPar(0),
69	fkDigClassName(), // String with digit class name.
70	fLoader(0), // local pointer to loader
71	fFirstcall(kTRUE),
72	fTriggerConditions(NULL)
73	{
74	// Default Constructor
75	// Inputs:
76	// none.
77	// Outputs:
78	// none.
79	// Return:
80	// A properly zero-ed AliITSDetTypeSimUpg class.
81	for (int i=kNDetTypes;i--;) fDetNModules[i] = 0;
82	fSimulation = new TObjArray(kNDetTypes);
83	fSegmentation = new TObjArray(kNDetTypes);
84	fSegmentation->SetOwner(kTRUE);
85	fDigits = new TObjArray(kNDetTypes);
86	fNDigits = new Int_t[kNDetTypes];
87	fSimuPar= new AliITSSimuParam();
88	SetRunNumber();
89	}
90
91	//----------------------------------------------------------------------
92	AliITSDetTypeSimUpg::~AliITSDetTypeSimUpg()
93	{
94	// Destructor
95	// Inputs:
96	// none.
97	// Outputs:
98	// none.
99	// Return:
100	// Nothing.
101
102	if(fSimulation){
103	fSimulation->Delete();
104	delete fSimulation;
105	}
106	//
107	if(fSegmentation){
108	fSegmentation->Delete();
109	delete fSegmentation;
110	}
111	//
112	if(fCalibration && fRunNumber<0){
113	fCalibration->Delete();
114	delete fCalibration;
115	}
116	//
117	delete fSimuPar;
118	delete[] fNDigits;
119	//
120	if (fLoader)fLoader->GetModulesFolder()->Remove(this); // Not deleting it.
121	fSDigits.Delete();
122	if (fDigits) {
123	fDigits->Delete();
124	delete fDigits;
125	}
126	//
127	}
128
129	//______________________________________________________________________
130	void AliITSDetTypeSimUpg::SetITSgeom(AliITSgeom *geom)
131	{
132	// Sets/replaces the existing AliITSgeom object kept in AliITSLoader
133	//
134	// Inputs:
135	// AliITSgoem *geom The AliITSgeom object to be used.
136	// Output:
137	// none.
138	// Return:
139	// none.
140	if(!fLoader){
141	Error("SetITSgeom","No pointer to loader - nothing done");
142	return;
143	}
144	else {
145	fLoader->SetITSgeom(geom); // protections in AliITSLoader::SetITSgeom
146	}
147
148	}
149
150	//______________________________________________________________________
151	void AliITSDetTypeSimUpg::SetLoader(AliITSLoader *loader)
152	{
153	// Sets the local copy of the AliITSLoader, and passes on the
154	// AliITSgeom object as needed.
155	// Inputs
156	// AliITSLoader *loader pointer to AliITSLoader for local use
157	// Outputs:
158	// none.
159	// Return:
160	// none.
161
162	if(fLoader==loader) return; // Same do nothing
163	if(fLoader){ // alread have an existing loader
164	Error("SetLoader","Already have an exisiting loader ptr=%p Nothing done",fLoader);
165	} // end if
166	fLoader = loader;
167	}
168
169	//______________________________________________________________________
170	void AliITSDetTypeSimUpg::SetSimulationModel(Int_t dettype,AliITSsimulation *sim)
171	{
172	//Set simulation model for detector type
173	if(fSimulation==0) fSimulation = new TObjArray(kNDetTypes);
174	fSimulation->AddAt(sim,dettype);
175	}
176
177	//______________________________________________________________________
178	AliITSsimulation* AliITSDetTypeSimUpg::GetSimulationModel(Int_t dettype) const
179	{
180	//Get simulation model for detector type
181	if(fSimulation==0) {
182	Warning("GetSimulationModel","fSimulation is 0!");
183	return 0;
184	}
185	return (AliITSsimulation*)(fSimulation->At(dettype));
186	}
187
188	//______________________________________________________________________
189	AliITSsimulation* AliITSDetTypeSimUpg::GetSimulationModelByModule(Int_t module) const
190	{
191	//Get simulation model by module number
192	if(GetITSgeom()==0) {
193	Warning("GetSimulationModelByModule","GetITSgeom() is 0!");
194	return 0;
195	}
196
197	return GetSimulationModel(GetITSgeom()->GetModuleType(module));
198	}
199
200	//_______________________________________________________________________
201	void AliITSDetTypeSimUpg::SetDefaultSegmentation(Int_t idet)
202	{
203	// Set default segmentation model objects
204	AliITSsegmentation *seg;
205	//
206	if(fSegmentation==0x0){
207	fSegmentation = new TObjArray(kNDetTypes);
208	fSegmentation->SetOwner(kTRUE);
209	}
210	if (GetSegmentationModel(idet)) delete (AliITSsegmentation*)fSegmentation->RemoveAt(idet);
211	//
212	switch (idet)
213	{
214	case kDetPixUpg: seg = new AliITSsegmentationPixUpg(); break;
215	default : AliFatal(Form("Uknown detector type %d",idet));
216	};
217	SetSegmentationModel(idet,seg);
218	//
219	}
220
221	//______________________________________________________________________
222	void AliITSDetTypeSimUpg::SetSegmentationModel(Int_t dettype, AliITSsegmentation *seg)
223	{
224	// Set segmentation model for detector type
225	if(fSegmentation==0x0){
226	fSegmentation = new TObjArray(kNDetTypes);
227	fSegmentation->SetOwner(kTRUE);
228	}
229	fSegmentation->AddAt(seg,dettype);
230	}
231
232	//______________________________________________________________________
233	AliITSsegmentation* AliITSDetTypeSimUpg::GetSegmentationModel(Int_t dettype) const
234	{
235	//Get segmentation model for detector type
236
237	if(fSegmentation==0) {
238	Warning("GetSegmentationModel","fSegmentation is 0!");
239	return 0;
240	}
241	return (AliITSsegmentation*)(fSegmentation->At(dettype));
242	}
243
244	//_______________________________________________________________________
245	AliITSsegmentation* AliITSDetTypeSimUpg::GetSegmentationModelByModule(Int_t module) const
246	{
247	//Get segmentation model by module number
248	if(GetITSgeom()==0) {
249	Warning("GetSegmentationModelByModule","GetITSgeom() is 0!");
250	return 0;
251	}
252	return GetSegmentationModel(GetITSgeom()->GetModuleType(module));
253	//
254	}
255
256	//_______________________________________________________________________
257	void AliITSDetTypeSimUpg::CreateCalibrationArray()
258	{
259	//Create the container of calibration functions with correct size
260	if (fCalibration) {
261	Warning("CreateCalibration","pointer to calibration object exists\n");
262	fCalibration->Delete();
263	delete fCalibration;
264	}
265	//
266	Int_t nModTot = GetITSgeom()->GetIndexMax();
267	fCalibration = new TObjArray(nModTot);
268	fCalibration->SetOwner(kTRUE);
269	fCalibration->Clear();
270	}
271
272	//_______________________________________________________________________
273	void AliITSDetTypeSimUpg::SetCalibrationModel(Int_t iMod, AliITSCalibration *resp)
274	{
275	//Set response model for modules
276
277	if (fCalibration==0) CreateCalibrationArray();
278
279	if (fCalibration->At(iMod)!=0) delete (AliITSCalibration*) fCalibration->At(iMod);
280	fCalibration->AddAt(resp, iMod);
281	}
282
283	//______________________________________________________________________
284	void AliITSDetTypeSimUpg::ResetCalibrationArray()
285	{
286	//resets response array
287	fCalibration->Clear();
288	}
289
290	//______________________________________________________________________
291	void AliITSDetTypeSimUpg::ResetSegmentation()
292	{
293	//Resets segmentation array
294	if(fSegmentation) fSegmentation->Clear();
295	}
296
297	//_______________________________________________________________________
298	AliITSCalibration* AliITSDetTypeSimUpg::GetCalibrationModel(Int_t iMod) const
299	{
300	//Get response model for module number iMod
301	//
302	if(fCalibration==0) {
303	AliError("fCalibration is 0!");
304	return 0;
305	}
306	return (AliITSCalibration*)fCalibration->At(iMod);
307	}
308
309	//_______________________________________________________________________
310	void AliITSDetTypeSimUpg::SetDefaults()
311	{
312	//Set defaults for segmentation and response
313
314	if(GetITSgeom()==0){
315	Warning("SetDefaults","GetITSgeom() is 0!");
316	return;
317	} // end if
318	if (fCalibration==0) {
319	CreateCalibrationArray();
320	} // end if
321
322	ResetSegmentation();
323	if(!GetCalibration()){AliFatal("Exit"); exit(0);}
324
325	SetDigitClassName(0,"AliITSdigitPixUpg");
326	//
327	for(Int_t idet=0;idet<kNDetTypes;idet++){
328	if(!GetSegmentationModel(idet)) SetDefaultSegmentation(idet);
329	}
330	//
331	}
332
333	//______________________________________________________________________
334	Bool_t AliITSDetTypeSimUpg::GetCalibration() {
335	// Get Default calibration if a storage is not defined.
336
337	if(!fFirstcall){
338	AliITSCalibration* cal = GetCalibrationModel(0);
339	if(cal)return kTRUE;
340	}
341	else {
342	fFirstcall = kFALSE;
343	}
344
345	SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
346	Int_t run=GetRunNumber();
347
348	Bool_t isCacheActive = kTRUE;
349	if (run) {
350	isCacheActive=kFALSE;
351	fCalibration->SetOwner(kTRUE);
352	}
353	else{
354	fCalibration->SetOwner(kFALSE);
355	}
356
357	AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
358	//
359	// TO DO, RS
360	return kTRUE;
361	}
362
363	//_______________________________________________________________________
364	void AliITSDetTypeSimUpg::SetDefaultSimulation()
365	{
366	//Set default simulation for detector type
367	//
368	if (GetITSgeom()==0) {
369	Warning("SetDefaultSimulation","GetITSgeom() is 0!");
370	return;
371	}
372	if (fCalibration==0) {
373	Warning("SetDefaultSimulation","fCalibration is 0!");
374	return;
375	}
376	if (fSegmentation==0) {
377	Warning("SetDefaultSimulation","fSegmentation is 0!");
378	for (Int_t i=0;i<kNDetTypes;i++) SetDefaultSegmentation(i);
379	} else for(Int_t i=0;i<kNDetTypes;i++) if(!GetSegmentationModel(i)){
380	Warning("SetDefaultSimulation",
381	"Segmentation not defined for det %d - Default taken\n!",i);
382	SetDefaultSegmentation(i);
383	}
384	//
385	AliITSsimulation* sim;
386	//
387	for (Int_t idet=0;idet<kNDetTypes;idet++) {
388	//OixUpg
389	if(idet==0){
390	sim = GetSimulationModel(idet);
391	if(!sim){
392	sim = new AliITSsimulationPixUpg(this);
393	SetSimulationModel(idet,sim);
394	}
395	}
396	}
397	}
398
399	//___________________________________________________________________
400	void AliITSDetTypeSimUpg::SetTreeAddressS(TTree* treeS, const Char_t* name)
401	{
402	// Set branch address for the ITS summable digits Trees.
403
404	if(!treeS) return;
405	TBranch *branch;
406	branch = treeS->GetBranch(name);
407	TClonesArray *sdigi = &fSDigits;
408	if (branch) branch->SetAddress(&sdigi);
409
410	}
411
412	//___________________________________________________________________
413	void AliITSDetTypeSimUpg::SetTreeAddressD(TTree* treeD, const Char_t* name)
414	{
415	// Set branch address for the digit Trees.
416	TBranch *branch;
417	TString branchname;
418	//
419	if(!treeD) return;
420	//
421	if(!fDigits) fDigits = new TObjArray(kNDetTypes);
422	//
423	for(Int_t i=0;i<kNDetTypes;i++){
424	const Char_t* digclass = GetDigitClassName(i);
425	if(digclass==0x0){
426	if(i==0) SetDigitClassName(i,Form("AliITSdigit%s",fgkDetTypeName[i]));
427	digclass = GetDigitClassName(i);
428	}
429	TString classn = digclass;
430	if(!(fDigits->At(i))){
431	fDigits->AddAt(new TClonesArray(classn.Data(),1000),i);
432	}else{
433	ResetDigits(i);
434	}
435	//
436	if(kNDetTypes==3) branchname.Form("%sDigits%s",name,fgkDetTypeName[i]);
437	branch = treeD->GetBranch(branchname.Data());
438	if(branch) branch->SetAddress(&((*fDigits)[i]));
439	}
440	}
441
442	//___________________________________________________________________
443	void AliITSDetTypeSimUpg::ResetDigits()
444	{
445	// Reset number of digits and the digits array for the ITS detector.
446	//
447	if(!fDigits){
448	Error("ResetDigits","fDigits is null!");
449	return;
450	}
451	for(Int_t i=0;i<kNDetTypes;i++) ResetDigits(i);
452	//
453	}
454
455	//___________________________________________________________________
456	void AliITSDetTypeSimUpg::ResetDigits(Int_t branch)
457	{
458	// Reset number of digits and the digits array for this branch.
459	//
460	if (fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
461	if(fNDigits) fNDigits[branch]=0;
462	}
463
464	//_______________________________________________________________________
465	void AliITSDetTypeSimUpg::SDigitsToDigits(Option_t* opt, Char_t* name)
466	{
467	// Standard Summable digits to Digits function.
468	if(!GetITSgeom()){
469	Warning("SDigitsToDigits","GetITSgeom() is null!!");
470	return;
471	}
472	//
473	static Bool_t setDef = kTRUE;
474	if(setDef) SetDefaultSimulation();
475	setDef = kFALSE;
476	//
477	AliITSsimulation *sim =0;
478	TTree* trees = fLoader->TreeS();
479	if( !(trees && GetSDigits()) ){
480	Error("SDigits2Digits","Error: No trees or SDigits. Returning.");
481	return;
482	}
483	//
484	TBranch* brchSDigits = trees->GetBranch(name);
485	//
486	Int_t id;
487	for(Int_t module=0;module<GetITSgeom()->GetIndexMax();module++) {
488	//
489	id = GetITSgeom()->GetModuleType(module);
490	sim = (AliITSsimulation*)GetSimulationModel(id);
491	if(!sim){
492	AliFatal(Form("The simulation class was not instanciated for module %d type %s!",
493	module,GetITSgeom()->GetModuleTypeName(module)));
494	}
495	sim->InitSimulationModule(module,gAlice->GetEvNumber());
496	//
497	fSDigits.Clear();
498	brchSDigits->GetEvent(module);
499	sim->AddSDigitsToModule(&fSDigits,0);
500	sim->FinishSDigitiseModule();
501	fLoader->TreeD()->Fill();
502	ResetDigits();
503	}
504	//
505	// WriteFOSignals();
506	fLoader->TreeD()->GetEntries();
507	fLoader->TreeD()->AutoSave();
508	fLoader->TreeD()->Reset();
509	}
510
511	//_________________________________________________________
512	void AliITSDetTypeSimUpg::AddSumDigit(AliITSpListItem &sdig)
513	{
514	//Adds the module full of summable digits to the summable digits tree.
515	new(fSDigits[fNSDigits++]) AliITSpListItem(sdig);
516	}
517
518	//__________________________________________________________
519	void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch, const AliITSdigit* d)
520	{
521	// Add a simulated digit.
522	TClonesArray &ldigits = ((TClonesArray)fDigits->At(branch));
523	switch(branch){
524	case kDetPixUpg:
525	new(ldigits[fNDigits[branch]++]) AliITSdigitPixUpg(((AliITSdigitPixUpg)d));
526	break;
527	default:
528	AliFatal(Form("Digit for unknown detector type %d",branch));
529	}
530	}
531
532	//______________________________________________________________________
533	void AliITSDetTypeSimUpg::AddSimDigit(Int_t branch,Float_t phys,Int_t *digits,
534	Int_t tracks,Int_t hits,Float_t *charges,
535	Int_t sigexpanded)
536	{
537	// Add a simulated digit to the list.
538
539	TClonesArray &ldigits = ((TClonesArray)fDigits->At(branch));
540	switch(branch){
541	case kDetPixUpg:
542	new(ldigits[fNDigits[branch]++]) AliITSdigitPixUpg(digits,tracks,hits);
543	break;
544	default:
545	AliFatal(Form("Digit for unknown detector type %d",branch));
546	}
547	}
548
549	//_______________________________________________________________________
550	AliITSTriggerConditions* AliITSDetTypeSimUpg::GetTriggerConditions()
551	{
552	// Get Pixel Trigger Conditions (separate method since it is used only when simulating trigger)
553	if (fTriggerConditions==NULL) { // read from db
554	fRunNumber = ((Int_t)AliCDBManager::Instance()->GetRun());
555	Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag();
556	Bool_t isCacheActive;
557	if (fRunNumber<0) isCacheActive=kFALSE;
558	else isCacheActive=kTRUE;
559	AliCDBManager::Instance()->SetCacheFlag(isCacheActive);
560	AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions", fRunNumber);
561	if (!pitCond) {
562	AliError("Trigger conditions retrieval failed! ");
563	return NULL;
564	}
565	fTriggerConditions = (AliITSTriggerConditions*) pitCond->GetObject();
566	if (!isCacheActive) pitCond->SetObject(NULL);
567	pitCond->SetOwner(kTRUE);
568	if (!isCacheActive) {
569	delete pitCond;
570	}
571	AliCDBManager::Instance()->SetCacheFlag(origCacheStatus);
572	if (fTriggerConditions==NULL) {
573	AliWarning("fTriggerConditions is NULL!");
574	}
575	}
576	return fTriggerConditions;
577	}
578