[u/mrichter/AliRoot.git] / MUON / AliMUONClusterReconstructor.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$ */

////////////////////////////////////
//
// MUON event reconstructor in ALICE
//
// This class contains as data:
// * the parameters for the event reconstruction
// * a pointer to the array of hits to be reconstructed (the event)
// * a pointer to the array of segments made with these hits inside each station
// * a pointer to the array of reconstructed tracks
//
// It contains as methods, among others:
// * MakeEventToBeReconstructed to build the array of hits to be reconstructed
// * MakeSegments to build the segments
// * MakeTracks to build the tracks
//
////////////////////////////////////

#include <Riostream.h> // for cout
#include <stdlib.h> // for exit()

#include <TTree.h>

#include "AliMUON.h"
#include "AliMUONClusterReconstructor.h"
#include "AliMUONDigit.h"
#include "AliMUONConstants.h"
#include "AliMUONData.h"
#include "AliMUONClusterFinderVS.h"
#include "AliMUONClusterFinderAZ.h"
#include "AliMUONClusterInput.h"
#include "AliMUONRawCluster.h"
#include "AliRun.h" // for gAlice
#include "AliConfig.h"
#include "AliRunLoader.h"
#include "AliLoader.h"

const Int_t AliMUONClusterReconstructor::fgkDefaultPrintLevel = 0;

ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context

//__________________________________________________________________________
AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
{
  // Default Constructor
 
  fDebug           = 0;
  fNCh             = 0;
  fNTrackingCh     = 0;
  fChambers        = 0;
  fMUONData        = 0;
  fChambers = new TObjArray(AliMUONConstants::NCh());

  fPrintLevel = fgkDefaultPrintLevel;

  // initialize loader's
  fLoader = loader;

  // initialize container
  fMUONData  = new AliMUONData(fLoader,"MUON","MUON");

  // Loading AliRun master
  AliRunLoader* runloader = fLoader->GetRunLoader();
  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
  gAlice = runloader->GetAliRun();

  // getting MUON
  fMUON = (AliMUON*) gAlice->GetDetector("MUON");

  return; 
}
//____________________________________________________________________
void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
{
  // take infos chambers from AliMUON
  AliMUONChamber* pCh = 0;
  pCh = &(fMUON->Chamber(id));

  fChambers->AddAt(pCh, id);

  // Set ClusterFinder for chamber id
  ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
}
//_______________________________________________________________________
AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& Reconstructor):TObject(Reconstructor)
{
  // Dummy copy constructor
}

AliMUONClusterReconstructor & AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& /*Reconstructor*/)
{
  // Dummy assignment operator
    return *this;
}

//__________________________________________________________________________
AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
{
  if (fChambers){
    fChambers->Clear(); // Sets pointers to 0 sinche it is not the owner
    delete fChambers;
  } 
  if (fMUONData)
    delete fMUONData;

  return;
}
//____________________________________________________________________
void AliMUONClusterReconstructor::Digits2Clusters()
{
//
//  Perform cluster finding
//
    TClonesArray *dig1, *dig2;
    Int_t ndig, k;
    dig1 = new TClonesArray("AliMUONDigit",1000);
    dig2 = new TClonesArray("AliMUONDigit",1000);
    AliMUONDigit *digit;
// Loop on chambers and on cathode planes
//
//    fMUONData->ResetRawClusters();        
    TClonesArray * muonDigits;

    for (Int_t ich = 0; ich < 10; ich++) {
 	AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
	AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
	//AliMUONClusterFinderAZ* rec = (AliMUONClusterFinderAZ*)iChamber->ReconstructionModel();

	fMUONData->ResetDigits();
	fMUONData->GetCathode(0);
	//TClonesArray *
	muonDigits = fMUONData->Digits(ich); 
	ndig=muonDigits->GetEntriesFast();
	if(fDebug)
	  printf("1 Found %d digits in %p chamber %d\n", ndig, (void*)muonDigits,ich);
	TClonesArray &lhits1 = *dig1;
	Int_t n = 0;
	for (k = 0; k < ndig; k++) {
	    digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
	    if (rec->TestTrack(digit->Track(0)))
	      new(lhits1[n++]) AliMUONDigit(*digit);
	}
	fMUONData->ResetDigits();
	fMUONData->GetCathode(1);
	muonDigits =  fMUONData->Digits(ich);  
	ndig=muonDigits->GetEntriesFast();
	if(fDebug)
	  printf("\n 2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich);
	TClonesArray &lhits2 = *dig2;
	n=0;
	
	for (k=0; k<ndig; k++) {
	    digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
	    if (rec->TestTrack(digit->Track(0)))
	      new(lhits2[n++]) AliMUONDigit(*digit);
	}

	if (rec) {	 
	    AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
	    rec->FindRawClusters();
	}
	// copy into the container
	TClonesArray* tmp = rec->GetRawClusters();
	for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
	  AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
	  fMUONData->AddRawCluster(ich, *pClus);
	}
	dig1->Delete();
	dig2->Delete();
    } // for ich
    delete dig1;
    delete dig2;
}
Commit	Line	Data
52c9bc11	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	/* $Id$ */
	17
	18	////////////////////////////////////
	19	//
	20	// MUON event reconstructor in ALICE
	21	//
	22	// This class contains as data:
	23	// * the parameters for the event reconstruction
	24	// * a pointer to the array of hits to be reconstructed (the event)
	25	// * a pointer to the array of segments made with these hits inside each station
	26	// * a pointer to the array of reconstructed tracks
	27	//
	28	// It contains as methods, among others:
	29	// * MakeEventToBeReconstructed to build the array of hits to be reconstructed
	30	// * MakeSegments to build the segments
	31	// * MakeTracks to build the tracks
	32	//
	33	////////////////////////////////////
	34
	35	#include <Riostream.h> // for cout
	36	#include <stdlib.h> // for exit()
	37
	38	#include <TTree.h>
	39
	40	#include "AliMUON.h"
	41	#include "AliMUONClusterReconstructor.h"
	42	#include "AliMUONDigit.h"
	43	#include "AliMUONConstants.h"
	44	#include "AliMUONData.h"
	45	#include "AliMUONClusterFinderVS.h"
	46	#include "AliMUONClusterFinderAZ.h"
	47	#include "AliMUONClusterInput.h"
	48	#include "AliMUONRawCluster.h"
	49	#include "AliRun.h" // for gAlice
	50	#include "AliConfig.h"
	51	#include "AliRunLoader.h"
	52	#include "AliLoader.h"
	53
343146bf	54	const Int_t AliMUONClusterReconstructor::fgkDefaultPrintLevel = 0;
52c9bc11	55
	56	ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
	57
	58	//__________________________________________________________________________
	59	AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
	60	{
	61	// Default Constructor
	62
	63	fDebug = 0;
	64	fNCh = 0;
	65	fNTrackingCh = 0;
	66	fChambers = 0;
	67	fMUONData = 0;
	68	fChambers = new TObjArray(AliMUONConstants::NCh());
	69
343146bf	70	fPrintLevel = fgkDefaultPrintLevel;
52c9bc11	71
	72	// initialize loader's
	73	fLoader = loader;
	74
	75	// initialize container
	76	fMUONData = new AliMUONData(fLoader,"MUON","MUON");
	77
	78	// Loading AliRun master
	79	AliRunLoader* runloader = fLoader->GetRunLoader();
	80	if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
	81	gAlice = runloader->GetAliRun();
	82
	83	// getting MUON
	84	fMUON = (AliMUON*) gAlice->GetDetector("MUON");
	85
	86	return;
	87	}
	88	//____________________________________________________________________
	89	void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
	90	{
	91	// take infos chambers from AliMUON
	92	AliMUONChamber* pCh = 0;
	93	pCh = &(fMUON->Chamber(id));
	94
	95	fChambers->AddAt(pCh, id);
	96
	97	// Set ClusterFinder for chamber id
	98	((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
	99	}
	100	//_______________________________________________________________________
	101	AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& Reconstructor):TObject(Reconstructor)
	102	{
	103	// Dummy copy constructor
	104	}
	105
	106	AliMUONClusterReconstructor & AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& /Reconstructor/)
	107	{
	108	// Dummy assignment operator
	109	return *this;
	110	}
	111
	112	//__________________________________________________________________________
	113	AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
	114	{
	115	if (fChambers){
86b48c39	116	fChambers->Clear(); // Sets pointers to 0 sinche it is not the owner
52c9bc11	117	delete fChambers;
	118	}
	119	if (fMUONData)
	120	delete fMUONData;
	121
	122	return;
	123	}
	124	//____________________________________________________________________
	125	void AliMUONClusterReconstructor::Digits2Clusters()
	126	{
	127	//
	128	// Perform cluster finding
	129	//
	130	TClonesArray dig1, dig2;
	131	Int_t ndig, k;
	132	dig1 = new TClonesArray("AliMUONDigit",1000);
	133	dig2 = new TClonesArray("AliMUONDigit",1000);
	134	AliMUONDigit *digit;
	135	// Loop on chambers and on cathode planes
	136	//
	137	// fMUONData->ResetRawClusters();
	138	TClonesArray * muonDigits;
	139
	140	for (Int_t ich = 0; ich < 10; ich++) {
	141	AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
	142	AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
	143	//AliMUONClusterFinderAZ* rec = (AliMUONClusterFinderAZ*)iChamber->ReconstructionModel();
	144
	145	fMUONData->ResetDigits();
	146	fMUONData->GetCathode(0);
	147	//TClonesArray *
	148	muonDigits = fMUONData->Digits(ich);
	149	ndig=muonDigits->GetEntriesFast();
	150	if(fDebug)
e81f4d4f	151	printf("1 Found %d digits in %p chamber %d\n", ndig, (void*)muonDigits,ich);
52c9bc11	152	TClonesArray &lhits1 = *dig1;
	153	Int_t n = 0;
	154	for (k = 0; k < ndig; k++) {
	155	digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
	156	if (rec->TestTrack(digit->Track(0)))
	157	new(lhits1[n++]) AliMUONDigit(*digit);
	158	}
	159	fMUONData->ResetDigits();
	160	fMUONData->GetCathode(1);
	161	muonDigits = fMUONData->Digits(ich);
	162	ndig=muonDigits->GetEntriesFast();
	163	if(fDebug)
e81f4d4f	164	printf("\n 2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich);
52c9bc11	165	TClonesArray &lhits2 = *dig2;
	166	n=0;
	167
	168	for (k=0; k<ndig; k++) {
	169	digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
	170	if (rec->TestTrack(digit->Track(0)))
	171	new(lhits2[n++]) AliMUONDigit(*digit);
	172	}
	173
	174	if (rec) {
	175	AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
	176	rec->FindRawClusters();
	177	}
	178	// copy into the container
	179	TClonesArray* tmp = rec->GetRawClusters();
	180	for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
	181	AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
	182	fMUONData->AddRawCluster(ich, *pClus);
	183	}
	184	dig1->Delete();
	185	dig2->Delete();
	186	} // for ich
	187	delete dig1;
	188	delete dig2;
	189	}