[u/mrichter/AliRoot.git] / ITS / AliITSreconstruction.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.                  *
 **************************************************************************/
 
/*
$Log$
Revision 1.5  2002/05/13 14:27:57  hristov
TreeC created once per event (M.Masera)

Revision 1.4  2002/05/10 22:31:30  nilsen
Changes by Massimo Masera to allow Recpoints and Clusters to be written
to separate files.

Revision 1.3  2002/02/06 13:52:27  barbera
gAlice deletion corrected (from M. Masera)

Revision 1.2  2002/01/31 18:52:09  nilsen
Minor change to allow the use of files that are already open. grun.C macro
that also does ITS digitizationa and Reconstruction all in one go.

Revision 1.1  2002/01/30 22:20:22  nilsen
New TTask based method to do Digits To clusters. Works with files of multiple
events in the file. Macro added to show how to use. Also the changes made
in the nessesary complilation files.

*/
#include <TROOT.h>
#include <TFile.h>
#include <TSeqCollection.h>
#include <TString.h>
#include <TClonesArray.h>

#include "AliRun.h"

#include "AliITS.h"
#include "AliITSDetType.h"
#include "AliITSreconstruction.h"
#include "AliITSsegmentationSPD.h"
#include "AliITSsegmentationSDD.h"
#include "AliITSsegmentationSSD.h"
#include "AliITSClusterFinderSPD.h"
#include "AliITSClusterFinderSDD.h"
#include "AliITSClusterFinderSSD.h"
#include "AliITSresponseSDD.h"
#include "AliITSgeom.h"

ClassImp(AliITSreconstruction)

//______________________________________________________________________
AliITSreconstruction::AliITSreconstruction(){
    // Default constructor.
    // Inputs:
    //  none.
    // Outputs:
    //   none.
    // Return:
    //    A zero-ed constructed AliITSreconstruction class.

    fFilename = "";
    fFile     = 0;
    fFile2    = 0;
    fITS      = 0;
    fDet[0] = fDet[1] = fDet[2] = kTRUE;
    fInit     = kFALSE;
    fArp      = 0;
    fDfArp    = kFALSE;
}
//______________________________________________________________________
AliITSreconstruction::AliITSreconstruction(AliRun *ar){
    // Standard constructor.
    // Inputs:
    //  AliRun *ar   Pointer to an existing AliRun object. Assumed that
    //               this AliRun object will not be deleted by this distructor.
    // Outputs:
    //   none.
    // Return:
    //    A standardly constructed AliITSreconstruction class.

    fFilename = "";
    fFile     = 0;
    fFile2    = 0;
    fITS      = 0;
    fDet[0] = fDet[1] = fDet[2] = kTRUE;
    fInit     = kFALSE;
    fDfArp    = kFALSE;
    fArp      = ar;
}
//______________________________________________________________________
AliITSreconstruction::AliITSreconstruction(const char* filename){
    // Standard constructor.
    // Inputs:
    //  const char* filename    filename containing the digits to be
    //                          reconstructed. If filename = 0 (nil)
    //                          then no file is opened but a file is
    //                          assumed to already be opened. This 
    //                          already opened file will be used.
    // Outputs:
    //   none.
    // Return:
    //    A standardly constructed AliITSreconstruction class.

    fFilename = filename;
    fFile2 = 0;
    fFile = 0;
    fArp      = 0;
    fDfArp    = kTRUE;
    if(filename){
	fFile = (TFile*)gROOT->GetListOfFiles()->FindObject(fFilename.Data());
	if(fFile) fFile->Close();
	fFile = new TFile(fFilename.Data(),"UPDATE");
    if(fArp) {
      delete fArp;
      fArp = 0;
    }
	fArp = (AliRun*)fFile->Get("gAlice");
	if(!fArp) {
	    cout << "gAlice not found on file. Aborting." << endl;
	    fInit = kFALSE;
	    return;
	} // end if !fArp
    } // end if !filename.
}
//______________________________________________________________________
AliITSreconstruction::~AliITSreconstruction(){
    // Default constructor.
    // Inputs:
    //  none.
    // Outputs:
    //   none.
    // Return:
    //    A destroyed AliITSreconstruction class.

    if(fFile) fFile->Close();
    fFile     = 0;
    fITS      = 0;
    if(fDfArp){
	if(fArp) delete fArp;
    } // end if
}
//______________________________________________________________________
Bool_t AliITSreconstruction::Init(){
    // Class Initilizer.
    // Inputs:
    //  none.
    // Outputs:
    //   none.
    // Return:
    //    kTRUE if no errors initilizing this class occurse else kFALSE
    Int_t nparticles;
    fITS = (AliITS*) fArp->GetDetector("ITS");
    if(!fITS){
	cout << "ITS not found aborting. fITS=" << fITS << endl;
	fInit = kFALSE;
	return fInit;
    } // end if !fITS
    if(!(fITS->GetITSgeom())){
	cout << "ITSgeom not found aborting."<< endl;
	fInit = kFALSE;
	return fInit;
    } // end if !GetITSgeom()
    // Now ready to init.

    fDet[0] = fDet[1] = fDet[2] = kTRUE;
    fEnt0 = 0;
    fEnt  = fArp->GetEventsPerRun();
    fITS->MakeTreeC();
    nparticles = fArp->GetEvent(fEnt0);
    
    // finished init.
    fInit = InitRec();
    return fInit;
}
//______________________________________________________________________
Bool_t AliITSreconstruction::InitRec(){
    // Sets up Reconstruction part of AliITSDetType..
    // Inputs:
    //      none.
    // Outputs:
    //      none.
    // Return:
    //      none.
    AliITSDetType *idt;

    // SPD
    if(fDet[kSPD]){
	idt = fITS->DetType(kSPD);
	AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)
	                                       idt->GetSegmentationModel();
	TClonesArray *digSPD = fITS->DigitsAddress(kSPD);
	TClonesArray *recpSPD = fITS->ClustersAddress(kSPD);
	AliITSClusterFinderSPD *recSPD = new AliITSClusterFinderSPD(segSPD,
								    digSPD,
								    recpSPD);
	fITS->SetReconstructionModel(kSPD,recSPD);
    } // end if fDet[kSPD].
    // SDD
    if(fDet[kSDD]){
	idt = fITS->DetType(kSDD);
	AliITSsegmentationSDD *segSDD = (AliITSsegmentationSDD*)
	                                   idt->GetSegmentationModel();
	AliITSresponseSDD *resSDD = (AliITSresponseSDD*)
	                                   idt->GetResponseModel();
	TClonesArray *digSDD = fITS->DigitsAddress(kSDD);
	TClonesArray *recpSDD = fITS->ClustersAddress(kSDD);
	AliITSClusterFinderSDD *recSDD =new AliITSClusterFinderSDD(segSDD,
								   resSDD,
							       digSDD,recpSDD);
	fITS->SetReconstructionModel(kSDD,recSDD);
    } // end if fDet[kSDD]
    // SSD
    if(fDet[kSSD]){
	idt = fITS->DetType(kSSD);
	AliITSsegmentationSSD *segSSD = (AliITSsegmentationSSD*)
	                                 idt->GetSegmentationModel();
	TClonesArray *digSSD = fITS->DigitsAddress(kSSD);
	AliITSClusterFinderSSD *recSSD =new AliITSClusterFinderSSD(segSSD,
								   digSSD);
	fITS->SetReconstructionModel(kSSD,recSSD);
    } // end if fDet[kSSD]

    return kTRUE;
}
//______________________________________________________________________ 
void AliITSreconstruction::Exec(const Option_t *opt){
    // Main reconstruction function.
    // Inputs:
    //      Option_t * opt   list of subdetector to digitize. =0 all.
    // Outputs:
    //      none.
    // Return:
    //      none.
    Option_t *lopt;
    Int_t nparticles,evnt;

    if(strstr(opt,"All")||strstr(opt,"ALL")||strstr(opt,"ITS")||opt==0){
	fDet[0] = fDet[1] = fDet[2] = kTRUE;
	lopt = "All";
    }else{
	fDet[0] = fDet[1] = fDet[2] = kFALSE;
	if(strstr(opt,"SPD")) fDet[kSPD] = kTRUE;
	if(strstr(opt,"SDD")) fDet[kSDD] = kTRUE;
	if(strstr(opt,"SSD")) fDet[kSSD] = kTRUE;
	if(fDet[kSPD] && fDet[kSDD] && fDet[kSSD]) lopt = "All";
	else lopt = opt;
    } // end if strstr(opt,...)

    if(!fInit){
	cout << "Initilization Failed, Can't run Exec." << endl;
	return;
    } // end if !fInit
    TDirectory *curr = gDirectory;
    if(fFile2)fFile2->cd();
    for(evnt=0;evnt<fEnt;evnt++){
      nparticles = fArp->GetEvent(evnt);
      fArp->SetEvent(evnt);
      if(!fArp->TreeR()){
        if(fFile2){
          fArp->MakeTree("R",fFile2);
        }
        else {
          fArp->MakeTree("R");
        }
      }
      fITS->MakeBranch("R");
      fITS->MakeTreeC();
      fITS->DigitsToRecPoints(evnt,0,lopt);
    } // end for evnt
    curr->cd();
}
//______________________________________________________________________ 
void AliITSreconstruction::SetOutputFile(TString filename){
  // Set a file name for recpoints. Used only if this file is not the file
  // containing digits. This obj is deleted by AliRun.
  fFile2 = fArp->InitTreeFile("R",filename);
}
Commit	Line	Data
	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	$Log$
	18	Revision 1.5 2002/05/13 14:27:57 hristov
	19	TreeC created once per event (M.Masera)
	20
	21	Revision 1.4 2002/05/10 22:31:30 nilsen
	22	Changes by Massimo Masera to allow Recpoints and Clusters to be written
	23	to separate files.
	24
	25	Revision 1.3 2002/02/06 13:52:27 barbera
	26	gAlice deletion corrected (from M. Masera)
	27
	28	Revision 1.2 2002/01/31 18:52:09 nilsen
	29	Minor change to allow the use of files that are already open. grun.C macro
	30	that also does ITS digitizationa and Reconstruction all in one go.
	31
	32	Revision 1.1 2002/01/30 22:20:22 nilsen
	33	New TTask based method to do Digits To clusters. Works with files of multiple
	34	events in the file. Macro added to show how to use. Also the changes made
	35	in the nessesary complilation files.
	36
	37	*/
	38	#include <TROOT.h>
	39	#include <TFile.h>
	40	#include <TSeqCollection.h>
	41	#include <TString.h>
	42	#include <TClonesArray.h>
	43
	44	#include "AliRun.h"
	45
	46	#include "AliITS.h"
	47	#include "AliITSDetType.h"
	48	#include "AliITSreconstruction.h"
	49	#include "AliITSsegmentationSPD.h"
	50	#include "AliITSsegmentationSDD.h"
	51	#include "AliITSsegmentationSSD.h"
	52	#include "AliITSClusterFinderSPD.h"
	53	#include "AliITSClusterFinderSDD.h"
	54	#include "AliITSClusterFinderSSD.h"
	55	#include "AliITSresponseSDD.h"
	56	#include "AliITSgeom.h"
	57
	58	ClassImp(AliITSreconstruction)
	59
	60	//______________________________________________________________________
	61	AliITSreconstruction::AliITSreconstruction(){
	62	// Default constructor.
	63	// Inputs:
	64	// none.
	65	// Outputs:
	66	// none.
	67	// Return:
	68	// A zero-ed constructed AliITSreconstruction class.
	69
	70	fFilename = "";
	71	fFile = 0;
	72	fFile2 = 0;
	73	fITS = 0;
	74	fDet[0] = fDet[1] = fDet[2] = kTRUE;
	75	fInit = kFALSE;
	76	fArp = 0;
	77	fDfArp = kFALSE;
	78	}
	79	//______________________________________________________________________
	80	AliITSreconstruction::AliITSreconstruction(AliRun *ar){
	81	// Standard constructor.
	82	// Inputs:
	83	// AliRun *ar Pointer to an existing AliRun object. Assumed that
	84	// this AliRun object will not be deleted by this distructor.
	85	// Outputs:
	86	// none.
	87	// Return:
	88	// A standardly constructed AliITSreconstruction class.
	89
	90	fFilename = "";
	91	fFile = 0;
	92	fFile2 = 0;
	93	fITS = 0;
	94	fDet[0] = fDet[1] = fDet[2] = kTRUE;
	95	fInit = kFALSE;
	96	fDfArp = kFALSE;
	97	fArp = ar;
	98	}
	99	//______________________________________________________________________
	100	AliITSreconstruction::AliITSreconstruction(const char* filename){
	101	// Standard constructor.
	102	// Inputs:
	103	// const char* filename filename containing the digits to be
	104	// reconstructed. If filename = 0 (nil)
	105	// then no file is opened but a file is
	106	// assumed to already be opened. This
	107	// already opened file will be used.
	108	// Outputs:
	109	// none.
	110	// Return:
	111	// A standardly constructed AliITSreconstruction class.
	112
	113	fFilename = filename;
	114	fFile2 = 0;
	115	fFile = 0;
	116	fArp = 0;
	117	fDfArp = kTRUE;
	118	if(filename){
	119	fFile = (TFile*)gROOT->GetListOfFiles()->FindObject(fFilename.Data());
	120	if(fFile) fFile->Close();
	121	fFile = new TFile(fFilename.Data(),"UPDATE");
	122	if(fArp) {
	123	delete fArp;
	124	fArp = 0;
	125	}
	126	fArp = (AliRun*)fFile->Get("gAlice");
	127	if(!fArp) {
	128	cout << "gAlice not found on file. Aborting." << endl;
	129	fInit = kFALSE;
	130	return;
	131	} // end if !fArp
	132	} // end if !filename.
	133	}
	134	//______________________________________________________________________
	135	AliITSreconstruction::~AliITSreconstruction(){
	136	// Default constructor.
	137	// Inputs:
	138	// none.
	139	// Outputs:
	140	// none.
	141	// Return:
	142	// A destroyed AliITSreconstruction class.
	143
	144	if(fFile) fFile->Close();
	145	fFile = 0;
	146	fITS = 0;
	147	if(fDfArp){
	148	if(fArp) delete fArp;
	149	} // end if
	150	}
	151	//______________________________________________________________________
	152	Bool_t AliITSreconstruction::Init(){
	153	// Class Initilizer.
	154	// Inputs:
	155	// none.
	156	// Outputs:
	157	// none.
	158	// Return:
	159	// kTRUE if no errors initilizing this class occurse else kFALSE
	160	Int_t nparticles;
	161	fITS = (AliITS*) fArp->GetDetector("ITS");
	162	if(!fITS){
	163	cout << "ITS not found aborting. fITS=" << fITS << endl;
	164	fInit = kFALSE;
	165	return fInit;
	166	} // end if !fITS
	167	if(!(fITS->GetITSgeom())){
	168	cout << "ITSgeom not found aborting."<< endl;
	169	fInit = kFALSE;
	170	return fInit;
	171	} // end if !GetITSgeom()
	172	// Now ready to init.
	173
	174	fDet[0] = fDet[1] = fDet[2] = kTRUE;
	175	fEnt0 = 0;
	176	fEnt = fArp->GetEventsPerRun();
	177	fITS->MakeTreeC();
	178	nparticles = fArp->GetEvent(fEnt0);
	179
	180	// finished init.
	181	fInit = InitRec();
	182	return fInit;
	183	}
	184	//______________________________________________________________________
	185	Bool_t AliITSreconstruction::InitRec(){
	186	// Sets up Reconstruction part of AliITSDetType..
	187	// Inputs:
	188	// none.
	189	// Outputs:
	190	// none.
	191	// Return:
	192	// none.
	193	AliITSDetType *idt;
	194
	195	// SPD
	196	if(fDet[kSPD]){
	197	idt = fITS->DetType(kSPD);
	198	AliITSsegmentationSPD segSPD = (AliITSsegmentationSPD)
	199	idt->GetSegmentationModel();
	200	TClonesArray *digSPD = fITS->DigitsAddress(kSPD);
	201	TClonesArray *recpSPD = fITS->ClustersAddress(kSPD);
	202	AliITSClusterFinderSPD *recSPD = new AliITSClusterFinderSPD(segSPD,
	203	digSPD,
	204	recpSPD);
	205	fITS->SetReconstructionModel(kSPD,recSPD);
	206	} // end if fDet[kSPD].
	207	// SDD
	208	if(fDet[kSDD]){
	209	idt = fITS->DetType(kSDD);
	210	AliITSsegmentationSDD segSDD = (AliITSsegmentationSDD)
	211	idt->GetSegmentationModel();
	212	AliITSresponseSDD resSDD = (AliITSresponseSDD)
	213	idt->GetResponseModel();
	214	TClonesArray *digSDD = fITS->DigitsAddress(kSDD);
	215	TClonesArray *recpSDD = fITS->ClustersAddress(kSDD);
	216	AliITSClusterFinderSDD *recSDD =new AliITSClusterFinderSDD(segSDD,
	217	resSDD,
	218	digSDD,recpSDD);
	219	fITS->SetReconstructionModel(kSDD,recSDD);
	220	} // end if fDet[kSDD]
	221	// SSD
	222	if(fDet[kSSD]){
	223	idt = fITS->DetType(kSSD);
	224	AliITSsegmentationSSD segSSD = (AliITSsegmentationSSD)
	225	idt->GetSegmentationModel();
	226	TClonesArray *digSSD = fITS->DigitsAddress(kSSD);
	227	AliITSClusterFinderSSD *recSSD =new AliITSClusterFinderSSD(segSSD,
	228	digSSD);
	229	fITS->SetReconstructionModel(kSSD,recSSD);
	230	} // end if fDet[kSSD]
	231
	232	return kTRUE;
	233	}
	234	//______________________________________________________________________
	235	void AliITSreconstruction::Exec(const Option_t *opt){
	236	// Main reconstruction function.
	237	// Inputs:
	238	// Option_t * opt list of subdetector to digitize. =0 all.
	239	// Outputs:
	240	// none.
	241	// Return:
	242	// none.
	243	Option_t *lopt;
	244	Int_t nparticles,evnt;
	245
	246	if(strstr(opt,"All")\|\|strstr(opt,"ALL")\|\|strstr(opt,"ITS")\|\|opt==0){
	247	fDet[0] = fDet[1] = fDet[2] = kTRUE;
	248	lopt = "All";
	249	}else{
	250	fDet[0] = fDet[1] = fDet[2] = kFALSE;
	251	if(strstr(opt,"SPD")) fDet[kSPD] = kTRUE;
	252	if(strstr(opt,"SDD")) fDet[kSDD] = kTRUE;
	253	if(strstr(opt,"SSD")) fDet[kSSD] = kTRUE;
	254	if(fDet[kSPD] && fDet[kSDD] && fDet[kSSD]) lopt = "All";
	255	else lopt = opt;
	256	} // end if strstr(opt,...)
	257
	258	if(!fInit){
	259	cout << "Initilization Failed, Can't run Exec." << endl;
	260	return;
	261	} // end if !fInit
	262	TDirectory *curr = gDirectory;
	263	if(fFile2)fFile2->cd();
	264	for(evnt=0;evnt<fEnt;evnt++){
	265	nparticles = fArp->GetEvent(evnt);
	266	fArp->SetEvent(evnt);
	267	if(!fArp->TreeR()){
	268	if(fFile2){
	269	fArp->MakeTree("R",fFile2);
	270	}
	271	else {
	272	fArp->MakeTree("R");
	273	}
	274	}
	275	fITS->MakeBranch("R");
	276	fITS->MakeTreeC();
	277	fITS->DigitsToRecPoints(evnt,0,lopt);
	278	} // end for evnt
	279	curr->cd();
	280	}
	281	//______________________________________________________________________
	282	void AliITSreconstruction::SetOutputFile(TString filename){
	283	// Set a file name for recpoints. Used only if this file is not the file
	284	// containing digits. This obj is deleted by AliRun.
	285	fFile2 = fArp->InitTreeFile("R",filename);
	286	}
	287
	288
	289
	290
	291