[u/mrichter/AliRoot.git] / ITS / AliITS.h

#ifndef ALIITS_H
#define ALIITS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

////////////////////////////////////////////////////////////////////////
//           Manager class for set: ITS                               //
////////////////////////////////////////////////////////////////////////

//#define NEWVERSION

#include <TObjArray.h> // used in inline function GetModule.
#include <TBranch.h>   // used in inline function SetHitsAddressBranch

#include "AliRunLoader.h"
#include "AliDetector.h"
#ifndef NEWVERSION
#include "AliITSDetType.h"
#endif
#ifdef NEWVERSION
#include "AliITSDetTypeSim.h"
#include "AliITSDetTypeRec.h"
#endif

class TString;
class TTree;
class TFile;

class AliITSsimulation;
class AliITSClusterFinder;
class AliITSclusterV2;
class AliITSLoader;
class AliITSsegmentation;
class AliITSresponse;
class AliITShit;
class AliITSgeom;
class AliITSpListItem;
class AliITSdigit;
class AliITSRecPoint;
class AliITSRawCluster;
class AliITSmodule;
class AliVertexer;
class AliDigitizer;
class AliRunDigitizer;
class AliRawReader;

const Int_t kNTYPES=3;

class AliITS : public AliDetector {

 public:
    //================= Standard Classes ===============================
    AliITS();  // Default creator.
    AliITS(const char *name, const char *title); // standard Creator
    virtual ~AliITS(); // destructor
    AliITS(const AliITS &source); // copy constructor. Not to be used!
    AliITS& operator=(AliITS &source); // = operator. Not to be used!
    virtual Int_t IsVersion() const {return 1;}
    virtual Int_t DistancetoPrimitive(Int_t,Int_t) const{return 999;};

    //===================== Simulation Geometry ========================
    // get geometry version - detailed (major) or coarse (minor)
    virtual Int_t GetMajorVersion() const {return -1;}
    virtual Int_t GetMinorVersion() const {return -1;}
    virtual void  GetGeometryVersion(Int_t &a,Int_t &b) 
	                   {a = GetMajorVersion();b=GetMinorVersion();return;}
    virtual void  SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
    virtual Bool_t GetEUCLID()const {return fEuclidOut;}
    //-------------------- Geometry Transformations --------------------
#ifndef NEWVERSION
    // ITS geometry functions
    AliITSgeom   *GetITSgeom() const {return fITSgeom;}
    // Sets ITS geometry ! be very careful using this function.
    void   SetITSgeom(AliITSgeom *geom) {fITSgeom = geom;}
    // return pointer to the array of modules
    TObjArray    *GetModules() const {return fITSmodules;}
    // return pointer to a particular module
    AliITSmodule *GetModule(Int_t index) {return (AliITSmodule *)
					      (fITSmodules->At(index));}
#endif
#ifdef NEWVERSION
    // ITS geometry functions
    AliITSgeom* GetITSgeom()const{if(fDetTypeSim!=0)
        return fDetTypeSim->GetITSgeom();else if(fDetTypeRec!=0) 
            return fDetTypeRec->GetITSgeom();else return 0;}
    // ITS geometry functions From Simulation
    AliITSgeom* GetITSgeomSim()const{if(fDetTypeSim!=0)
        return fDetTypeSim->GetITSgeom();else return 0;}
    // ITS geometry functions From Reconstruction
    AliITSgeom* GetITSgeomRec()const{if(fDetTypeRec!=0)
        return fDetTypeRec->GetITSgeom();else return 0;}
    // Sets ITS geometry ! be very careful using this function.
    void   SetITSgeom(AliITSgeom *geom) {if(fDetTypeSim!=0)
        fDetTypeSim->SetITSgeom(geom);if(fDetTypeRec!=0) 
            fDetTypeRec->SetITSgeom(geom);}
    // Sets ITS geometry For Simulation ! be very careful using this function.
    void   SetITSgeomSim(AliITSgeom *geom) {if(fDetTypeSim!=0)
        fDetTypeSim->SetITSgeom(geom);}
    // Sets ITS geometry For Reconstruction! be very careful using this fun.
    void   SetITSgeomRec(AliITSgeom *geom) {if(fDetTypeRec!=0)
        fDetTypeRec->SetITSgeom(geom);}
    // return pointer to the array of modules
    TObjArray    *GetModules() const {return fDetTypeSim->GetModules();}
    // return pointer to a particular module
    AliITSmodule *GetModule(Int_t index){return fDetTypeSim->GetModule(index);}
#endif

    //================ Necessary general Classes =======================
    virtual void Init();
    virtual AliLoader* MakeLoader(const char* topfoldername);
    virtual void SetDefaults();
    virtual void SetDefaultSimulation();
    virtual void SetDefaultClusterFinders();
    virtual void SetDefaultClusterFindersV2();
    virtual void MakeBranch(Option_t *opt=" ");
    virtual void SetTreeAddress();
#ifndef NEWVERSION
    // For a given branch from the treeH sets the TClonesArray address.
    virtual void SetHitsAddressBranch(TBranch *b) {b->SetAddress(&fHits);}
    // Return pointer to DetType #id
    AliITSDetType *DetType(Int_t id){
        return ((AliITSDetType*) fDetTypes->At(id));};
    //Int_t           NDetTypes() {return fNDetTypes;}
#endif
    //---------- Configuration Methods (per detector type) -------------
    // Determines which ITS subdetectors will be processed. Effects
    // digitization, and Reconstruction only.
    void SetDetectors(Option_t *opt="All"){fOpt = opt;}
    // Returns the list of ITS subdetectors that will be processed.
    Option_t* GetDetectors(){return fOpt;}
#ifndef NEWVERSION
    // Set response 
    virtual void SetResponseModel(Int_t id, AliITSresponse *response){
        ((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);};
    // Set segmentation 
    virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
        ((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);};
    // Set simulation - temporary 
    virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
        ((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);};
    // Set simulation - temporary 
    virtual AliITSsimulation* GetSimulationModel(Int_t id){
	return ((AliITSDetType*)(fDetTypes->At(id)))->GetSimulationModel();}
    // Set reconstruction 
    virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
        ((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(rec);};
    // Set class names for digit and rec point 
    virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
        ((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);};
#endif
#ifdef NEWVERSION
    // Set response
    virtual void SetResponseModel(Int_t module, AliITSresponse *response){
        fDetTypeSim->SetResponseModel(module,response);};
    // Set segmentation for Simulation
    virtual void SetSegmentationModelSim(Int_t id, AliITSsegmentation *seg){
        fDetTypeSim->SetSegmentationModel(id,seg);};
    // Set segmentation for Reconstruction
    virtual void SetSegmentationModelRec(Int_t id, AliITSsegmentation *seg){
        fDetTypeRec->SetSegmentationModel(id,seg);};
    // Set segmentation 
    virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
        SetSegmentationModelSim(id,seg);SetSegmentationModelRec(id,seg);};
    // Set simulation 
    virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
        fDetTypesSim->SetSimulationModel(sim);};
    // Set simulation 
    virtual AliITSsimulation* GetSimulationModel(Int_t id){
	return fDetTypesSim->GetSimulationModel(id);}
    // Set Calibration
    virtual void SetCalibrationModel(Int_t module, AliITSCalibration *cal){
        fDetTypeRec->SetCalibrationModel(module,cal);};
    // Set reconstruction 
    virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
        fDetTypesRec->SetReconstructionModel(id,rec);};
    // Set Class name for Hits
    virtual void SetHitClassName(){
        fDetTypeSim->SetHitClassName(this->GetName());}
    // Set Class name for SDigits
    virtual void SetSDigitClassName(const char *sdigit){
        fDetTypeSim->SetSDigitClassName(sdigit);}
    // Set Class name for Digits for simulation
    virtual void SetDigitClassNameSim(const char *digit){
        fDetTypeSim->SetDigitClassName(digit);}///////// Array of names
    // Set Class name for Digits for Reconstruction
    virtual void SetDigitClassNameRec(const char *digit){
        fDetTypeRec->SetDigitClassName(digit);}///////// Array of names
    virtual void SetClusterClassName(const char *digit){
        fDetTypeRec->SetClusterClassName(digit);}///////// Array of names
    virtual void SetRecPointClassName(const char *digit){
        fDetTypeRec->SetRecPointClassName(digit);}///////// Array of names
    // Set class names for digit and rec point 
    virtual void SetClasses(Int_t id, const char *digit, const char *cluster){
        SetDigitClassNameSim(digit);SetDigitClassNameRec(digit);
        SetRecPointClassName(cluster);};
#endif

    //=================== Hits =========================================
    virtual void StepManager() {} // See Step Manager for specific geometry.
    //------------ sort hits by module for Digitisation ----------------
    virtual void FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
			     Option_t *opt, const char *filename);
#ifndef NEWVERSION
    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits);
    virtual void InitModules(Int_t size,Int_t &nmodules);  
    virtual void FillModules(TTree *treeH, Int_t mask = 0);
    virtual void ClearModules(){if(fITSmodules) fITSmodules->Delete();};
#endif
#ifdef NEWVERSION
    virtual void AddHit(Int_t track, Int_t *vol, Float_t *hits){
        if(fDetTypeSim!=0)fDetTypeSim->AddHit(track,vol,hits);};
    virtual void AddHit(AliITShit &hit){
        if(fDetTypeSim!=0)fDetTypeSim->AddHit(hit);};
    virtual void InitModules(Int_t size,Int_t &nmodules){if(fDetTypeSim!=0)
        fDetTypeSim->InitModules(size,nmodules);};
    virtual void FillModules(TTree *treeH, Int_t mask = 0){if(fDetTypeSim!=0)
        fDetTypeSim->FillModules(treeH,mask);};
    virtual void ClearModules(){if(fDetTypeSim!=0) 
        fDetTypeSim->ClearModules();};
#endif

    //===================== Digitisation ===============================
#ifndef NEWVERSION
    void MakeBranchS(const char *file);
    void SetTreeAddressS(TTree *treeS);
    TClonesArray * GetSDigits() { return fSDigits; }
    void MakeBranchInTreeD(TTree *treeD,const char *file=0);
    void MakeBranchD(const char *file){
	MakeBranchInTreeD(GetLoader()->TreeD(),file);}
    void SetTreeAddressD(TTree *treeD);
#endif
#ifndef NEWVERSION
    void Hits2SDigits(); // Turn hits into SDigits
    void Hits2PreDigits(){ // Turn hits into SDigits
        HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
                        0,-1," ",fOpt," ");};
    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
    void SDigits2Digits(){SDigitsToDigits("All");} // Turn SDigits to Digits
    void SDigitsToDigits(Option_t *opt="All"); // Turn SDigits to Digits
    void Hits2Digits(); // Turn hits straight into Digits.
    //------------------ Internal functions ----------------------------
    // Standard Hits To SDigits function
    void HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
                       Option_t *add, Option_t *det, const char *filename)
        {HitsToPreDigits(evNumber,bgrev,size,add,det,filename);};
    // Standard Hits To SDigits function
    void HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
                 Option_t *add, Option_t *det, const char *filename);
    // Standard Hits To Digits function
    void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
                 Option_t *add, Option_t *det, const char *filename);
#endif
#ifdef NEWVERSION
    // Turn hits into SDigits
    void Hits2SDigits(){if(fDetTypeSim)fDetTypeSim->Hits2SDigits();};
    AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
    // Turn SDigits to Digits
    void SDigits2Digits(){if(fDetTypeSim)fDetTypeSim->SDigits2Digits();} 
    // Turn hits straight into Digits.
    void Hits2Digits(){if(fDetTypeSim)fDetTypeSim->Hits2Digits();};
#endif
    // Resets the Summable digits.
#ifndef NEWVERSION
    void ResetSDigits(){if(fSDigits) fSDigits->Clear();fNSDigits = 0;};
    void ResetDigits();                   // depending on how the
    void ResetDigits(Int_t branch);       // tree will be filled only
    void AddSumDigit(AliITSpListItem &sdig);
    void AddRealDigit(Int_t branch, Int_t *digits);
    void AddSimDigit(Int_t branch, AliITSdigit *d);
    void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
		     Int_t* tracks,Int_t *hits,Float_t* trkcharges);
#endif
    // Return pointers to digits 
#ifndef NEWVERSION
    TObjArray    *Dtype() {return fDtype;}
    Int_t        *Ndtype() {return fNdtype;}
    TClonesArray *DigitsAddress(Int_t id)
	{return ((TClonesArray *) (*fDtype)[id]);}
#endif
#ifdef NEWVERSION
    TObjArray* GetDigitsSim(){if(fDetTypeSim!=0) 
        return fDetTypeSim->GetDigits();else return 0;}
    TObjArray* GetDigitsRec(){if(fDetTypeRec!=0) 
        return fDetTypeRec->GetDigits();else return 0;}
    TObjArray    *Dtype() {if(fDetTypeSim!=0) return GetDigitsSim();
    else if(fDetTypeRec!=0) return GetDigitsRec(); else return 0;}
    Int_t* GetNDigitArraySim(){if(fDetTypeSim!=0) 
        fDetTypeSim->GetNDigitArray();}
    Int_t* GetNDigitArrayRec(){if(fDetTypeRec!=0) 
        fDetTypeRec->GetNDigitArray();}
    Int_t        *Ndtype() {if(fDetTypeSim!=0) return GetNDigitArraySim();
        else if(fDetTypeRec!=0) return GetNDigitArrayRec(); else return 0;}
    TClonesArray *DigitsAddressSim(Int_t id){if(fDetTypeSim!=0)
	return fDetTypeSim->GetDigitsAddress(id);else return 0;}
    TClonesArray *DigitsAddressRec(Int_t id){if(fDetTypeRec!=0)
	return fDetTypeRec->GetDigitsAddress(id);else return 0;}
    TClonesArray *DigitsAddress(Int_t id){if(fDetTypeSim!=0)
	return DigitsAddressSim(id);else if(fDetTypeRec!=0) DigitsAddressRec(id);
     else return 0;}
#endif
    void SelectVertexer(TString sel=" "){fSelectedVertexer = sel;}
#ifndef NEWVERSION

    //===================== Raw Data IO ================================
    // Write digits into raw data format
    virtual void Digits2Raw();

    //==================== Clusterization ==============================
    // create separate tree for clusters - declustering refining
    void MakeTreeC(Option_t *option="C");
    void GetTreeC(Int_t event);
    void AddCluster(Int_t branch, AliITSRawCluster *c);
    // one of the methods in
    void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);}; 
    void ResetClusters(Int_t branch);     // the pair will be kept
    void MakeBranchC();
    // Return pointers to clusters 
    TObjArray    *Ctype() {return fCtype;}
    Int_t        *Nctype() {return fNctype;}
    TClonesArray *ClustersAddress(Int_t id) 
                   {return ((TClonesArray *) (*fCtype)[id]);}
#endif
#ifdef NEWVERSION

    //===================== Raw Data IO ================================
    // Write digits into raw data format
    virtual void Digits2Raw(){if(fDetTypeSim)fDetTypeSim->Digits2Raw();};

    //==================== Clusterization ==============================
    // create separate tree for clusters - declustering refining
    void MakeTreeC(Option_t *option="C"){fDetTypeRec->MakeTreeC();};
    void GetTreeC(Int_t event){fDetTypeRec->GetTreeC(event);};
    void AddCluster(Int_t branch, AliITSRawCluster *c){
        fDetTypeRec->AddCluster(branch,c);};
    // one of the methods in
    void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);}; 
    void ResetClusters(Int_t branch){fDetTypeRec->ResetCluster(i);};
    void MakeBranchC(){fDetTypeRec->MakeBranchC();};
    // Return pointers to clusters 
    TObjArray    *Ctype() {if(fDetTypeRec!=0)
        return fDetTypeRec->GetClusterArray(); else return 0;}
    Int_t        *Nctype() {if(fDetTypeRec!=0) 
        return fDetTypeRec->GetNClusters(); else return 0;;}
    TClonesArray *ClustersAddress(Int_t id){if(fDetTypeRec!=0) 
        return fDetTypeRec->GetClusterAddress(id]); else return 0;}
#endif

    //=================== Reconstruction ===============================
#ifndef NEWVERSION
    void MakeBranchR(const char *file, Option_t *opt=" ");
    void SetTreeAddressR(TTree *treeR);
    void AddRecPoint(const AliITSRecPoint &p);
    void ResetRecPoints(){if(fRecPoints) fRecPoints->Clear();fNRecPoints = 0;};
    // Return pointer to rec points 
    TClonesArray  *RecPoints()   {return fRecPoints;}

    void AddClusterV2(const AliITSclusterV2 &cl);
    void ResetClustersV2(){if(fClustersV2) fClustersV2->Clear();fNClustersV2=0;} 
    Int_t GetNClustersV2()const {return fNClustersV2;}
// Return pointer to clustersV2
TClonesArray *ClustersV2() {return fClustersV2;}
#endif
#ifdef NEWVERSION
    void MakeBranchR(const char *file, Option_t *opt=" ");
    void SetTreeAddressR(TTree *treeR){fDetTypeRec->SetTreeAddressR(treeR);};
    void AddRecPoint(const AliITSRecPoint &p){fDetTypeRec->AddRecPoint(p);};
    void ResetRecPoints(){if(fDetTypeRec) fDetTypeRec->ResetRecPoints();};
    // Return pointer to rec points 
    TClonesArray* RecPoints() {if(fDetTypeRec!=0)
        return fDetTypeRec->GetRecPoints();else return 0;}
#endif
    void MakeBranchRF(const char *file){MakeBranchR(file,"Fast");}
    void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
                 Option_t *add, Option_t *det, const char *filename);
    void Digits2Reco(){
        DigitsToRecPoints(fLoader->GetRunLoader()->GetEventNumber(),0,fOpt);};
    void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
void DigitsToRecPoints(AliRawReader* rawReader);
 protected:
    //================== Data Members ==================================
#ifdef NEWVERSION
    AliITSDetTypeSim *fDetTypeSim; //
    AliITSDetTypeRec *fDetTypeRec; //
#endif
#ifndef NEWVERSION
    AliITSgeom   *fITSgeom;    // Pointer to ITS geometry
#endif
    Bool_t        fEuclidOut;  // Flag to write geometry in euclid format
#ifndef NEWVERSION
    TObjArray    *fITSmodules; //! Pointer to ITS modules
#endif
    Option_t     *fOpt;        //! Detector option ="All" unless changed.

    Int_t         fIdN;        // the number of layers
    Int_t        *fIdSens;     //[fIdN] layer identifier
    TString      *fIdName;     //[fIdN] layer identifier
#ifndef NEWVERSION
    Int_t         fNDetTypes;  // Number of detector types
    TObjArray    *fDetTypes;   // List of detector types

    TClonesArray  *fSDigits;    //! List of Summable digits.
    Int_t         fNSDigits;   // Number of Summable Digits.

    TObjArray    *fDtype;      //! List of digits
    Int_t        *fNdtype;     //[fNDetTypes] Num. of digits per type of det. 

    TObjArray    *fCtype;      //! List of clusters
    Int_t        *fNctype;     //[fNDetTypes] Num. of clust. per type of det.

    TClonesArray *fRecPoints;  //! List of reconstructed points
    Int_t         fNRecPoints; // Number of rec points

    TClonesArray *fClustersV2; //!List of reconstructed clusters v2
    Int_t         fNClustersV2;    //Number of clusters v2

#endif
    TString fSelectedVertexer; // Vertexer selected in CreateVertexer
#ifndef NEWVERSION
    ClassDef(AliITS,5) // Base class for ITS
#endif
#ifdef NEWVERSION
    ClassDef(AliITS,5) // Base class for ITS
#endif
};

#endif
Commit	Line	Data
3bd79107	1	#ifndef ALIITS_H
3bd79107	2	#define ALIITS_H
3da30618	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
58005f18	8	////////////////////////////////////////////////////////////////////////
3bd79107	9	// Manager class for set: ITS //
58005f18	10	////////////////////////////////////////////////////////////////////////
fe4da5cc	11
7e932df0	12	//#define NEWVERSION
7e932df0	13
143d1056	14	#include <TObjArray.h> // used in inline function GetModule.
cd77595e	15	#include <TBranch.h> // used in inline function SetHitsAddressBranch
3bd79107	16
5d766c75	17	#include "AliRunLoader.h"
fe4da5cc	18	#include "AliDetector.h"
7e932df0	19	#ifndef NEWVERSION
54b8cf3b	20	#include "AliITSDetType.h"
7e932df0	21	#endif
	22	#ifdef NEWVERSION
	23	#include "AliITSDetTypeSim.h"
	24	#include "AliITSDetTypeRec.h"
	25	#endif
de82972f	26
d5da1ecf	27	class TString;
d5da1ecf	28	class TTree;
55b5a0b3	29	class TFile;
fe4da5cc	30
3bd79107	31	class AliITSsimulation;
3bd79107	32	class AliITSClusterFinder;
04366a57	33	class AliITSclusterV2;
88cb7938	34	class AliITSLoader;
de82972f	35	class AliITSsegmentation;
	36	class AliITSresponse;
	37	class AliITShit;
	38	class AliITSgeom;
2aea926d	39	class AliITSpListItem;
de82972f	40	class AliITSdigit;
	41	class AliITSRecPoint;
	42	class AliITSRawCluster;
	43	class AliITSmodule;
2257f27e	44	class AliVertexer;
aacedc3e	45	class AliDigitizer;
aacedc3e	46	class AliRunDigitizer;
04366a57	47	class AliRawReader;
27a043b1	48
a8a6107b	49	const Int_t kNTYPES=3;
de82972f	50
3bd79107	51	class AliITS : public AliDetector {
58005f18	52
2aea926d	53	public:
	54	//================= Standard Classes ===============================
	55	AliITS(); // Default creator.
	56	AliITS(const char name, const char title); // standard Creator
	57	virtual ~AliITS(); // destructor
ac74f489	58	AliITS(const AliITS &source); // copy constructor. Not to be used!
2aea926d	59	AliITS& operator=(AliITS &source); // = operator. Not to be used!
2aea926d	60	virtual Int_t IsVersion() const {return 1;}
aacedc3e	61	virtual Int_t DistancetoPrimitive(Int_t,Int_t) const{return 999;};
2aea926d	62
2aea926d	63	//===================== Simulation Geometry ========================
e8189707	64	// get geometry version - detailed (major) or coarse (minor)
93f82b23	65	virtual Int_t GetMajorVersion() const {return -1;}
93f82b23	66	virtual Int_t GetMinorVersion() const {return -1;}
2aea926d	67	virtual void GetGeometryVersion(Int_t &a,Int_t &b)
2aea926d	68	{a = GetMajorVersion();b=GetMinorVersion();return;}
41b19549	69	virtual void SetEUCLID(Bool_t euclid=kTRUE) {fEuclidOut = euclid;}
a8e8915c	70	virtual Bool_t GetEUCLID()const {return fEuclidOut;}
2aea926d	71	//-------------------- Geometry Transformations --------------------
7e932df0	72	#ifndef NEWVERSION
2aea926d	73	// ITS geometry functions
2aea926d	74	AliITSgeom *GetITSgeom() const {return fITSgeom;}
f91c3e58	75	// Sets ITS geometry ! be very careful using this function.
f91c3e58	76	void SetITSgeom(AliITSgeom *geom) {fITSgeom = geom;}
2aea926d	77	// return pointer to the array of modules
	78	TObjArray *GetModules() const {return fITSmodules;}
	79	// return pointer to a particular module
	80	AliITSmodule GetModule(Int_t index) {return (AliITSmodule )
	81	(fITSmodules->At(index));}
7e932df0	82	#endif
	83	#ifdef NEWVERSION
	84	// ITS geometry functions
	85	AliITSgeom* GetITSgeom()const{if(fDetTypeSim!=0)
	86	return fDetTypeSim->GetITSgeom();else if(fDetTypeRec!=0)
	87	return fDetTypeRec->GetITSgeom();else return 0;}
	88	// ITS geometry functions From Simulation
	89	AliITSgeom* GetITSgeomSim()const{if(fDetTypeSim!=0)
	90	return fDetTypeSim->GetITSgeom();else return 0;}
	91	// ITS geometry functions From Reconstruction
	92	AliITSgeom* GetITSgeomRec()const{if(fDetTypeRec!=0)
	93	return fDetTypeRec->GetITSgeom();else return 0;}
	94	// Sets ITS geometry ! be very careful using this function.
	95	void SetITSgeom(AliITSgeom *geom) {if(fDetTypeSim!=0)
	96	fDetTypeSim->SetITSgeom(geom);if(fDetTypeRec!=0)
	97	fDetTypeRec->SetITSgeom(geom);}
	98	// Sets ITS geometry For Simulation ! be very careful using this function.
	99	void SetITSgeomSim(AliITSgeom *geom) {if(fDetTypeSim!=0)
	100	fDetTypeSim->SetITSgeom(geom);}
	101	// Sets ITS geometry For Reconstruction! be very careful using this fun.
	102	void SetITSgeomRec(AliITSgeom *geom) {if(fDetTypeRec!=0)
	103	fDetTypeRec->SetITSgeom(geom);}
	104	// return pointer to the array of modules
	105	TObjArray *GetModules() const {return fDetTypeSim->GetModules();}
	106	// return pointer to a particular module
	107	AliITSmodule *GetModule(Int_t index){return fDetTypeSim->GetModule(index);}
	108	#endif
3bd79107	109
88cb7938	110	//================ Necessary general Classes =======================
2aea926d	111	virtual void Init();
88cb7938	112	virtual AliLoader* MakeLoader(const char* topfoldername);
2aea926d	113	virtual void SetDefaults();
	114	virtual void SetDefaultSimulation();
	115	virtual void SetDefaultClusterFinders();
04366a57	116	virtual void SetDefaultClusterFindersV2();
88cb7938	117	virtual void MakeBranch(Option_t *opt=" ");
2aea926d	118	virtual void SetTreeAddress();
7e932df0	119	#ifndef NEWVERSION
93f82b23	120	// For a given branch from the treeH sets the TClonesArray address.
93f82b23	121	virtual void SetHitsAddressBranch(TBranch *b) {b->SetAddress(&fHits);}
2aea926d	122	// Return pointer to DetType #id
aacedc3e	123	AliITSDetType *DetType(Int_t id){
aacedc3e	124	return ((AliITSDetType*) fDetTypes->At(id));};
2aea926d	125	//Int_t NDetTypes() {return fNDetTypes;}
7e932df0	126	#endif
2aea926d	127	//---------- Configuration Methods (per detector type) -------------
7d8046e8	128	// Determines which ITS subdetectors will be processed. Effects
	129	// digitization, and Reconstruction only.
	130	void SetDetectors(Option_t *opt="All"){fOpt = opt;}
	131	// Returns the list of ITS subdetectors that will be processed.
	132	Option_t* GetDetectors(){return fOpt;}
7e932df0	133	#ifndef NEWVERSION
3bd79107	134	// Set response
aacedc3e	135	virtual void SetResponseModel(Int_t id, AliITSresponse *response){
aacedc3e	136	((AliITSDetType*) fDetTypes->At(id))->ResponseModel(response);};
3bd79107	137	// Set segmentation
aacedc3e	138	virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
aacedc3e	139	((AliITSDetType*) fDetTypes->At(id))->SegmentationModel(seg);};
3bd79107	140	// Set simulation - temporary
aacedc3e	141	virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
aacedc3e	142	((AliITSDetType*) fDetTypes->At(id))->SimulationModel(sim);};
54b8cf3b	143	// Set simulation - temporary
	144	virtual AliITSsimulation* GetSimulationModel(Int_t id){
	145	return ((AliITSDetType*)(fDetTypes->At(id)))->GetSimulationModel();}
3bd79107	146	// Set reconstruction
aacedc3e	147	virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
aacedc3e	148	((AliITSDetType*) fDetTypes->At(id))->ReconstructionModel(rec);};
3bd79107	149	// Set class names for digit and rec point
aacedc3e	150	virtual void SetClasses(Int_t id, const char digit, const char cluster){
aacedc3e	151	((AliITSDetType*) fDetTypes->At(id))->ClassNames(digit,cluster);};
7e932df0	152	#endif
	153	#ifdef NEWVERSION
	154	// Set response
	155	virtual void SetResponseModel(Int_t module, AliITSresponse *response){
	156	fDetTypeSim->SetResponseModel(module,response);};
	157	// Set segmentation for Simulation
	158	virtual void SetSegmentationModelSim(Int_t id, AliITSsegmentation *seg){
	159	fDetTypeSim->SetSegmentationModel(id,seg);};
	160	// Set segmentation for Reconstruction
	161	virtual void SetSegmentationModelRec(Int_t id, AliITSsegmentation *seg){
	162	fDetTypeRec->SetSegmentationModel(id,seg);};
	163	// Set segmentation
	164	virtual void SetSegmentationModel(Int_t id, AliITSsegmentation *seg){
	165	SetSegmentationModelSim(id,seg);SetSegmentationModelRec(id,seg);};
	166	// Set simulation
	167	virtual void SetSimulationModel(Int_t id, AliITSsimulation *sim){
	168	fDetTypesSim->SetSimulationModel(sim);};
	169	// Set simulation
	170	virtual AliITSsimulation* GetSimulationModel(Int_t id){
	171	return fDetTypesSim->GetSimulationModel(id);}
	172	// Set Calibration
	173	virtual void SetCalibrationModel(Int_t module, AliITSCalibration *cal){
	174	fDetTypeRec->SetCalibrationModel(module,cal);};
	175	// Set reconstruction
	176	virtual void SetReconstructionModel(Int_t id, AliITSClusterFinder *rec){
	177	fDetTypesRec->SetReconstructionModel(id,rec);};
	178	// Set Class name for Hits
	179	virtual void SetHitClassName(){
	180	fDetTypeSim->SetHitClassName(this->GetName());}
	181	// Set Class name for SDigits
	182	virtual void SetSDigitClassName(const char *sdigit){
	183	fDetTypeSim->SetSDigitClassName(sdigit);}
	184	// Set Class name for Digits for simulation
	185	virtual void SetDigitClassNameSim(const char *digit){
	186	fDetTypeSim->SetDigitClassName(digit);}///////// Array of names
	187	// Set Class name for Digits for Reconstruction
	188	virtual void SetDigitClassNameRec(const char *digit){
	189	fDetTypeRec->SetDigitClassName(digit);}///////// Array of names
	190	virtual void SetClusterClassName(const char *digit){
	191	fDetTypeRec->SetClusterClassName(digit);}///////// Array of names
	192	virtual void SetRecPointClassName(const char *digit){
	193	fDetTypeRec->SetRecPointClassName(digit);}///////// Array of names
	194	// Set class names for digit and rec point
	195	virtual void SetClasses(Int_t id, const char digit, const char cluster){
	196	SetDigitClassNameSim(digit);SetDigitClassNameRec(digit);
	197	SetRecPointClassName(cluster);};
	198	#endif
2aea926d	199
	200	//=================== Hits =========================================
	201	virtual void StepManager() {} // See Step Manager for specific geometry.
2aea926d	202	//------------ sort hits by module for Digitisation ----------------
2aea926d	203	virtual void FillModules(Int_t evnt,Int_t bgrev,Int_t nmodules,
8e8eae84	204	Option_t opt, const char filename);
7e932df0	205	#ifndef NEWVERSION
	206	virtual void AddHit(Int_t track, Int_t vol, Float_t hits);
	207	virtual void InitModules(Int_t size,Int_t &nmodules);
	208	virtual void FillModules(TTree *treeH, Int_t mask = 0);
aacedc3e	209	virtual void ClearModules(){if(fITSmodules) fITSmodules->Delete();};
7e932df0	210	#endif
	211	#ifdef NEWVERSION
	212	virtual void AddHit(Int_t track, Int_t vol, Float_t hits){
	213	if(fDetTypeSim!=0)fDetTypeSim->AddHit(track,vol,hits);};
	214	virtual void AddHit(AliITShit &hit){
	215	if(fDetTypeSim!=0)fDetTypeSim->AddHit(hit);};
	216	virtual void InitModules(Int_t size,Int_t &nmodules){if(fDetTypeSim!=0)
	217	fDetTypeSim->InitModules(size,nmodules);};
	218	virtual void FillModules(TTree *treeH, Int_t mask = 0){if(fDetTypeSim!=0)
	219	fDetTypeSim->FillModules(treeH,mask);};
	220	virtual void ClearModules(){if(fDetTypeSim!=0)
	221	fDetTypeSim->ClearModules();};
	222	#endif
2aea926d	223
2aea926d	224	//===================== Digitisation ===============================
7e932df0	225	#ifndef NEWVERSION
2aea926d	226	void MakeBranchS(const char *file);
2aea926d	227	void SetTreeAddressS(TTree *treeS);
f91c3e58	228	TClonesArray * GetSDigits() { return fSDigits; }
9ad8b5dd	229	void MakeBranchInTreeD(TTree treeD,const char file=0);
9ad8b5dd	230	void MakeBranchD(const char *file){
8f726cb3	231	MakeBranchInTreeD(GetLoader()->TreeD(),file);}
2aea926d	232	void SetTreeAddressD(TTree *treeD);
7e932df0	233	#endif
7e932df0	234	#ifndef NEWVERSION
2aea926d	235	void Hits2SDigits(); // Turn hits into SDigits
aacedc3e	236	void Hits2PreDigits(){ // Turn hits into SDigits
5d766c75	237	HitsToPreDigits(fLoader->GetRunLoader()->GetEventNumber(),
aacedc3e	238	0,-1," ",fOpt," ");};
c92eb8ad	239	AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
e0fc0305	240	void SDigits2Digits(){SDigitsToDigits("All");} // Turn SDigits to Digits
e0fc0305	241	void SDigitsToDigits(Option_t *opt="All"); // Turn SDigits to Digits
2aea926d	242	void Hits2Digits(); // Turn hits straight into Digits.
	243	//------------------ Internal functions ----------------------------
	244	// Standard Hits To SDigits function
	245	void HitsToSDigits(Int_t evNumber,Int_t bgrev,Int_t size,
aacedc3e	246	Option_t add, Option_t det, const char *filename)
aacedc3e	247	{HitsToPreDigits(evNumber,bgrev,size,add,det,filename);};
2aea926d	248	// Standard Hits To SDigits function
2aea926d	249	void HitsToPreDigits(Int_t evNumber,Int_t bgrev,Int_t size,
8e8eae84	250	Option_t add, Option_t det, const char *filename);
2aea926d	251	// Standard Hits To Digits function
2aea926d	252	void HitsToDigits(Int_t evNumber,Int_t bgrev,Int_t size,
8e8eae84	253	Option_t add, Option_t det, const char *filename);
7e932df0	254	#endif
	255	#ifdef NEWVERSION
	256	// Turn hits into SDigits
	257	void Hits2SDigits(){if(fDetTypeSim)fDetTypeSim->Hits2SDigits();};
	258	AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
	259	// Turn SDigits to Digits
	260	void SDigits2Digits(){if(fDetTypeSim)fDetTypeSim->SDigits2Digits();}
	261	// Turn hits straight into Digits.
	262	void Hits2Digits(){if(fDetTypeSim)fDetTypeSim->Hits2Digits();};
	263	#endif
aacedc3e	264	// Resets the Summable digits.
7e932df0	265	#ifndef NEWVERSION
aacedc3e	266	void ResetSDigits(){if(fSDigits) fSDigits->Clear();fNSDigits = 0;};
2aea926d	267	void ResetDigits(); // depending on how the
	268	void ResetDigits(Int_t branch); // tree will be filled only
	269	void AddSumDigit(AliITSpListItem &sdig);
	270	void AddRealDigit(Int_t branch, Int_t *digits);
	271	void AddSimDigit(Int_t branch, AliITSdigit *d);
	272	void AddSimDigit(Int_t branch,Float_t phys,Int_t* digits,
	273	Int_t* tracks,Int_t hits,Float_t trkcharges);
7e932df0	274	#endif
2aea926d	275	// Return pointers to digits
7e932df0	276	#ifndef NEWVERSION
2aea926d	277	TObjArray *Dtype() {return fDtype;}
	278	Int_t *Ndtype() {return fNdtype;}
	279	TClonesArray *DigitsAddress(Int_t id)
	280	{return ((TClonesArray ) (fDtype)[id]);}
7e932df0	281	#endif
	282	#ifdef NEWVERSION
	283	TObjArray* GetDigitsSim(){if(fDetTypeSim!=0)
	284	return fDetTypeSim->GetDigits();else return 0;}
	285	TObjArray* GetDigitsRec(){if(fDetTypeRec!=0)
	286	return fDetTypeRec->GetDigits();else return 0;}
	287	TObjArray *Dtype() {if(fDetTypeSim!=0) return GetDigitsSim();
	288	else if(fDetTypeRec!=0) return GetDigitsRec(); else return 0;}
	289	Int_t* GetNDigitArraySim(){if(fDetTypeSim!=0)
	290	fDetTypeSim->GetNDigitArray();}
	291	Int_t* GetNDigitArrayRec(){if(fDetTypeRec!=0)
	292	fDetTypeRec->GetNDigitArray();}
	293	Int_t *Ndtype() {if(fDetTypeSim!=0) return GetNDigitArraySim();
	294	else if(fDetTypeRec!=0) return GetNDigitArrayRec(); else return 0;}
	295	TClonesArray *DigitsAddressSim(Int_t id){if(fDetTypeSim!=0)
	296	return fDetTypeSim->GetDigitsAddress(id);else return 0;}
	297	TClonesArray *DigitsAddressRec(Int_t id){if(fDetTypeRec!=0)
	298	return fDetTypeRec->GetDigitsAddress(id);else return 0;}
	299	TClonesArray *DigitsAddress(Int_t id){if(fDetTypeSim!=0)
	300	return DigitsAddressSim(id);else if(fDetTypeRec!=0) DigitsAddressRec(id);
	301	else return 0;}
	302	#endif
2257f27e	303	void SelectVertexer(TString sel=" "){fSelectedVertexer = sel;}
7e932df0	304	#ifndef NEWVERSION
3bd79107	305
2aea926d	306	//===================== Raw Data IO ================================
2aea926d	307	// Write digits into raw data format
0421c3d1	308	virtual void Digits2Raw();
58005f18	309
2aea926d	310	//==================== Clusterization ==============================
	311	// create separate tree for clusters - declustering refining
	312	void MakeTreeC(Option_t *option="C");
	313	void GetTreeC(Int_t event);
	314	void AddCluster(Int_t branch, AliITSRawCluster *c);
aacedc3e	315	// one of the methods in
aacedc3e	316	void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);};
2aea926d	317	void ResetClusters(Int_t branch); // the pair will be kept
7e932df0	318	void MakeBranchC();
3bd79107	319	// Return pointers to clusters
2aea926d	320	TObjArray *Ctype() {return fCtype;}
	321	Int_t *Nctype() {return fNctype;}
	322	TClonesArray *ClustersAddress(Int_t id)
3bd79107	323	{return ((TClonesArray ) (fCtype)[id]);}
7e932df0	324	#endif
	325	#ifdef NEWVERSION
	326
	327	//===================== Raw Data IO ================================
	328	// Write digits into raw data format
	329	virtual void Digits2Raw(){if(fDetTypeSim)fDetTypeSim->Digits2Raw();};
	330
	331	//==================== Clusterization ==============================
	332	// create separate tree for clusters - declustering refining
	333	void MakeTreeC(Option_t *option="C"){fDetTypeRec->MakeTreeC();};
	334	void GetTreeC(Int_t event){fDetTypeRec->GetTreeC(event);};
	335	void AddCluster(Int_t branch, AliITSRawCluster *c){
	336	fDetTypeRec->AddCluster(branch,c);};
	337	// one of the methods in
	338	void ResetClusters(){for(Int_t i=0;i<kNTYPES;i++ ) ResetClusters(i);};
	339	void ResetClusters(Int_t branch){fDetTypeRec->ResetCluster(i);};
	340	void MakeBranchC(){fDetTypeRec->MakeBranchC();};
	341	// Return pointers to clusters
	342	TObjArray *Ctype() {if(fDetTypeRec!=0)
	343	return fDetTypeRec->GetClusterArray(); else return 0;}
	344	Int_t *Nctype() {if(fDetTypeRec!=0)
	345	return fDetTypeRec->GetNClusters(); else return 0;;}
	346	TClonesArray *ClustersAddress(Int_t id){if(fDetTypeRec!=0)
	347	return fDetTypeRec->GetClusterAddress(id]); else return 0;}
	348	#endif
3bd79107	349
2aea926d	350	//=================== Reconstruction ===============================
7e932df0	351	#ifndef NEWVERSION
ff0e455e	352	void MakeBranchR(const char file, Option_t opt=" ");
2aea926d	353	void SetTreeAddressR(TTree *treeR);
2aea926d	354	void AddRecPoint(const AliITSRecPoint &p);
aacedc3e	355	void ResetRecPoints(){if(fRecPoints) fRecPoints->Clear();fNRecPoints = 0;};
3bd79107	356	// Return pointer to rec points
3bd79107	357	TClonesArray *RecPoints() {return fRecPoints;}
04366a57	358
	359	void AddClusterV2(const AliITSclusterV2 &cl);
	360	void ResetClustersV2(){if(fClustersV2) fClustersV2->Clear();fNClustersV2=0;}
	361	Int_t GetNClustersV2()const {return fNClustersV2;}
	362	// Return pointer to clustersV2
	363	TClonesArray *ClustersV2() {return fClustersV2;}
7e932df0	364	#endif
	365	#ifdef NEWVERSION
	366	void MakeBranchR(const char file, Option_t opt=" ");
	367	void SetTreeAddressR(TTree *treeR){fDetTypeRec->SetTreeAddressR(treeR);};
	368	void AddRecPoint(const AliITSRecPoint &p){fDetTypeRec->AddRecPoint(p);};
	369	void ResetRecPoints(){if(fDetTypeRec) fDetTypeRec->ResetRecPoints();};
	370	// Return pointer to rec points
	371	TClonesArray* RecPoints() {if(fDetTypeRec!=0)
	372	return fDetTypeRec->GetRecPoints();else return 0;}
	373	#endif
	374	void MakeBranchRF(const char *file){MakeBranchR(file,"Fast");}
	375	void HitsToFastRecPoints(Int_t evNumber,Int_t bgrev,Int_t size,
	376	Option_t add, Option_t det, const char *filename);
	377	void Digits2Reco(){
	378	DigitsToRecPoints(fLoader->GetRunLoader()->GetEventNumber(),0,fOpt);};
	379	void DigitsToRecPoints(Int_t evNumber,Int_t lastEntry,Option_t *det);
04366a57	380	void DigitsToRecPoints(AliRawReader* rawReader);
2aea926d	381	protected:
2aea926d	382	//================== Data Members ==================================
7e932df0	383	#ifdef NEWVERSION
	384	AliITSDetTypeSim *fDetTypeSim; //
	385	AliITSDetTypeRec *fDetTypeRec; //
	386	#endif
	387	#ifndef NEWVERSION
2aea926d	388	AliITSgeom *fITSgeom; // Pointer to ITS geometry
7e932df0	389	#endif
e0fc0305	390	Bool_t fEuclidOut; // Flag to write geometry in euclid format
7e932df0	391	#ifndef NEWVERSION
2aea926d	392	TObjArray *fITSmodules; //! Pointer to ITS modules
7e932df0	393	#endif
7d8046e8	394	Option_t *fOpt; //! Detector option ="All" unless changed.
3bd79107	395
e0fc0305	396	Int_t fIdN; // the number of layers
2aea926d	397	Int_t *fIdSens; //[fIdN] layer identifier
2aea926d	398	TString *fIdName; //[fIdN] layer identifier
7e932df0	399	#ifndef NEWVERSION
e0fc0305	400	Int_t fNDetTypes; // Number of detector types
2aea926d	401	TObjArray *fDetTypes; // List of detector types
e8189707	402
88cb7938	403	TClonesArray *fSDigits; //! List of Summable digits.
2aea926d	404	Int_t fNSDigits; // Number of Summable Digits.
55b5a0b3	405
88cb7938	406	TObjArray *fDtype; //! List of digits
2aea926d	407	Int_t *fNdtype; //[fNDetTypes] Num. of digits per type of det.
3bd79107	408
88cb7938	409	TObjArray *fCtype; //! List of clusters
2aea926d	410	Int_t *fNctype; //[fNDetTypes] Num. of clust. per type of det.
3bd79107	411
88cb7938	412	TClonesArray *fRecPoints; //! List of reconstructed points
2aea926d	413	Int_t fNRecPoints; // Number of rec points
04366a57	414
	415	TClonesArray *fClustersV2; //!List of reconstructed clusters v2
	416	Int_t fNClustersV2; //Number of clusters v2
	417
7e932df0	418	#endif
2257f27e	419	TString fSelectedVertexer; // Vertexer selected in CreateVertexer
7e932df0	420	#ifndef NEWVERSION
04366a57	421	ClassDef(AliITS,5) // Base class for ITS
7e932df0	422	#endif
	423	#ifdef NEWVERSION
	424	ClassDef(AliITS,5) // Base class for ITS
	425	#endif
fe4da5cc	426	};
3bd79107	427
fe4da5cc	428	#endif