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

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  T0 (T-Zero) Detector                                            //
//  This class contains the base procedures for the T0     //
//  detector                                                                 //
//                                                                           //
//Begin_Html
/*
<img src="gif/AliT0Class.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>The responsible person for this module is
<a href="mailto:Alla.Maevskaia@cern.ch">Alla Maevskaia</a>.
</font>
<pre>
*/
//End_Html
//                                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <Riostream.h>

#include <TFile.h>
#include <TGeometry.h>
#include <TMath.h>
#include <TNode.h>
#include <TParticle.h>
#include <TRandom.h>
#include <TTUBE.h>
#include <TVirtualMC.h>
#include <AliESD.h>

#include "AliLog.h"
#include "AliMC.h"
#include "AliLoader.h"
#include "AliRun.h"
#include "TClonesArray.h"
#include "AliT0.h"
#include "AliT0Loader.h"
#include "AliT0digit.h"
#include "AliT0hit.h"
#include "AliT0Digitizer.h"
#include "AliT0RawData.h"
#include "AliT0RecPoint.h"
#include "AliLog.h"

ClassImp(AliT0)

  //static  AliT0digit *digits; 

//_____________________________________________________________________________
AliT0::AliT0()
  : AliDetector(), fIdSens(0), fDigits(NULL), fRecPoints(NULL)
{
  //
  // Default constructor for class AliT0
  //
  fIshunt   = 1;
  fHits     = 0;
  fDigits   = 0;
  fRecPoints = 0;
}
 
//_____________________________________________________________________________
AliT0::AliT0(const char *name, const char *title)
  : AliDetector(name,title), fIdSens(0), fDigits(new AliT0digit()), fRecPoints(new AliT0RecPoint())
{
  //
  // Standard constructor for T0 Detector
  //

  
  //
  // Initialise Hit array
  fHits       = new TClonesArray("AliT0hit",  405);
  gAlice->GetMCApp()->AddHitList(fHits);
  //  fDigits    = new AliT0digit();
  //  fRecPoints = new AliT0RecPoint();
  fIshunt     =  1;
  //  fIdSens   =  0;
  //PH  SetMarkerColor(kRed);
}

//_____________________________________________________________________________
AliT0::~AliT0() {
  
  if (fHits) {
    fHits->Delete();
    delete fHits;
  }
  /*
  if (fDigits) {
    fDigits->Delete();
    delete fDigits;
    cout<<" delete fDigits; "<<endl;
  }
  if (fRecPoints) {
   fRecPoints ->Delete();
    delete fRecPoints;
    cout<<" delete fRecPoints; "<<endl;
  }
  */ 
}

//_____________________________________________________________________________
void AliT0::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{
  //
  // Add a T0 hit
  //
  TClonesArray &lhits = *fHits;
  new(lhits[fNhits++]) AliT0hit(fIshunt,track,vol,hits);
}


//_____________________________________________________________________________

void AliT0::AddDigit(Int_t besttimeright, Int_t besttimeleft, Int_t meantime, 
			Int_t timediff, Int_t sumMult,
			TArrayI *time, TArrayI *adc, TArrayI *timeAmp, TArrayI *adcAmp)
{
  
  //  Add a T0 digit to the list.
 //
  
  if (!fDigits) {
    fDigits = new AliT0digit();
  }
  fDigits-> SetTimeBestRight(besttimeright);
  fDigits->SetTimeBestLeft(besttimeleft);
  fDigits-> SetMeanTime(meantime);
  fDigits-> SetDiffTime(timediff);
  fDigits-> SetSumMult(sumMult);
  fDigits->SetTime(*time);
  fDigits->SetTimeAmp(*timeAmp);
  fDigits->SetADC(*adc);
  fDigits->SetADCAmp(*adcAmp);
}


//_____________________________________________________________________________
void AliT0::BuildGeometry()
{
  //
  // Build simple ROOT TNode geometry for event display
  //
  TNode *node, *top;
  const int kColorT0  = 19;

  top=gAlice->GetGeometry()->GetNode("alice");

  // T0 define the different volumes
  new TRotMatrix("rotx999","rot999",  90,0,90,90,180,0);

  new TTUBE("S_0ST1","T0  volume 1","void",5.,10.7,5.3);
  top->cd();
  node = new TNode("0ST1","0ST01","S_0ST1",0,0,-69.7,"");
  node->SetLineColor(kColorT0);
  fNodes->Add(node);

  new TTUBE("S_0ST2","T0 volume 2","void",5.,10.7,5.3);
  top->cd();
  node = new TNode("0ST2","0ST2","S_0ST2",0,0,350,"rotx999");
  node->SetLineColor(kColorT0);
  fNodes->Add(node);
}
 
//_____________________________________________________________________________
Int_t AliT0::DistanceToPrimitive(Int_t /*px*/, Int_t /*py*/)
{
  //
  // Calculate the distance from the mouse to the T0 on the screen
  // Dummy routine
  //
  return 9999;
}
 
//-------------------------------------------------------------------------
void AliT0::Init()
{
  //
  // Initialis the T0 after it has been built
  Int_t i;
  //
  if(AliLog::GetGlobalDebugLevel()>0) {
    printf("\n%s: ",ClassName());
    for(i=0;i<35;i++) printf("*");
    printf(" T0_INIT ");
    for(i=0;i<35;i++) printf("*");
    printf("\n%s: ",ClassName());
    //
    // Here the T0 initialisation code (if any!)
    for(i=0;i<80;i++) printf("*");
    printf("\n");
  }
}

//---------------------------------------------------------------------------
void AliT0::MakeBranch(Option_t* option)
{
  //
// Create Tree branches for the T0.

 // Options:
  //
  //    H          Make a branch of TClonesArray of AliT0Hit's
  //    D          Make a branch of TClonesArray of AliT0Digit's
  //
  //    R         Make a branch of  AliT0RecPoints
  //
  char branchname[20];
  sprintf(branchname,"%s",GetName());

  const char *cH = strstr(option,"H");
  const char *cD = strstr(option,"D");
  const char *cR = strstr(option,"R");

    if (cH && fLoader->TreeH())
  {
     if (fHits == 0x0) fHits  = new TClonesArray("AliT0hit",  405);
     AliDetector::MakeBranch(option);
  } 
    
    
  if (cD && fLoader->TreeD())
    {
      if (fDigits == 0x0) fDigits  = new AliT0digit();
      //     MakeBranchInTree(fLoader->TreeD(), branchname,
      //		       &fDigits, 405, 0);
      fLoader->TreeD()->Branch(branchname,"AliT0digit",&fDigits,405,1);
      //   fLoader->TreeD()->Print();
    } 
  if (cR && fLoader->TreeR())
    {
      if (fRecPoints == 0x0) fRecPoints  = new AliT0RecPoint();
      MakeBranchInTree(fLoader->TreeR(), branchname,
		       &fRecPoints, 405, 0);
    } 
  
}    

//_____________________________________________________________________________
void AliT0::ResetHits()
{
  AliDetector::ResetHits();
  
}
//____________________________________________________________________
void AliT0::ResetDigits()
{
  //
  // Reset number of digits and the digits array for this detector
  //
  if (fDigits) fDigits->Clear();
}

//_____________________________________________________________________________
void AliT0::SetTreeAddress()
{

  TTree    *treeH;
  treeH = TreeH();
  
  if (treeH)
    {
      if (fHits == 0x0) fHits  = new TClonesArray("AliT0hit",  405);
    }
    
  AliDetector::SetTreeAddress();
  TTree *treeD = fLoader->TreeD();
  if (treeD) {
    if (fDigits == 0x0)  fDigits  = new AliT0digit();
    TBranch* branch = treeD->GetBranch ("T0");
    if (branch) branch->SetAddress(&fDigits);
  }

  TTree *treeR = fLoader->TreeR();
  if (treeR) {
    if (fRecPoints == 0x0) fRecPoints  = new  AliT0RecPoint()  ;
    TBranch* branch = treeR->GetBranch ("T0");
    if (branch) branch->SetAddress(&fRecPoints);
  }
 
}


//_____________________________________________________________________________
void AliT0::MakeBranchInTreeD(TTree *treeD, const char *file)
{
    //
    // Create TreeD branches for the FMD
    //
    const Int_t kBufferSize = 4000;
    char branchname[20];
    sprintf(branchname,"%s",GetName());
    if(treeD)
     {
       MakeBranchInTree(treeD,  branchname,&fDigits, kBufferSize, file);
     }
}

//_____________________________________________________________________________
AliDigitizer* AliT0::CreateDigitizer(AliRunDigitizer* manager) const
{
  return new AliT0Digitizer(manager);
}
//____________________________________________________________________________
void AliT0::Digits2Raw()
{
//
// Starting from the T0 digits, writes the Raw Data objects
//
//  AliT0Loader* pStartLoader = (AliT0Loader*)fLoader;
  fLoader ->LoadDigits("read");
  TTree* treeD = fLoader->TreeD();
  if (!treeD) {
    AliError("no digits tree");
    return;
  }
  if (fDigits == 0x0)  fDigits  = new AliT0digit();
  
  TBranch *branch = treeD->GetBranch("T0");
  if (branch) {
    branch->SetAddress(&fDigits);
  }else{
    AliError("Branch T0 DIGIT not found");
    exit(111);
  } 
  AliT0RawData rawWriter;
  rawWriter.SetVerbose(0);
  
  AliDebug(2,Form(" Formatting raw data for T0 "));
  branch->GetEntry(0);
  //  rawWriter.RawDataT0(treeD->GetBranch("T0"));
  rawWriter.RawDataT0(fDigits);
  
  
  fLoader->UnloadDigits();
  
}
Commit	Line	Data
dc7ca31d	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	// T0 (T-Zero) Detector //
	21	// This class contains the base procedures for the T0 //
	22	// detector //
	23	// //
	24	//Begin_Html
	25	/*
	26	<img src="gif/AliT0Class.gif">
	27	</pre>
	28	<br clear=left>
	29	<font size=+2 color=red>
	30	<p>The responsible person for this module is
	31	<a href="mailto:Alla.Maevskaia@cern.ch">Alla Maevskaia</a>.
	32	</font>
	33	<pre>
	34	*/
	35	//End_Html
	36	// //
	37	// //
	38	///////////////////////////////////////////////////////////////////////////////
	39
	40	#include <Riostream.h>
	41
	42	#include <TFile.h>
	43	#include <TGeometry.h>
	44	#include <TMath.h>
	45	#include <TNode.h>
	46	#include <TParticle.h>
	47	#include <TRandom.h>
	48	#include <TTUBE.h>
	49	#include <TVirtualMC.h>
	50	#include <AliESD.h>
	51
	52	#include "AliLog.h"
	53	#include "AliMC.h"
	54	#include "AliLoader.h"
	55	#include "AliRun.h"
	56	#include "TClonesArray.h"
	57	#include "AliT0.h"
	58	#include "AliT0Loader.h"
	59	#include "AliT0digit.h"
	60	#include "AliT0hit.h"
	61	#include "AliT0Digitizer.h"
	62	#include "AliT0RawData.h"
	63	#include "AliT0RecPoint.h"
	64	#include "AliLog.h"
65
66	ClassImp(AliT0)
67
68	//static AliT0digit *digits;
69
70	//_____________________________________________________________________________
71	AliT0::AliT0()
72	: AliDetector(), fIdSens(0), fDigits(NULL), fRecPoints(NULL)
73	{
74	//
75	// Default constructor for class AliT0
76	//
77	fIshunt = 1;
78	fHits = 0;
79	fDigits = 0;
80	fRecPoints = 0;
81	}
82
83	//_____________________________________________________________________________
84	AliT0::AliT0(const char name, const char title)
85	: AliDetector(name,title), fIdSens(0), fDigits(new AliT0digit()), fRecPoints(new AliT0RecPoint())
86	{
87	//
88	// Standard constructor for T0 Detector
89	//
90
91
92	//
93	// Initialise Hit array
94	fHits = new TClonesArray("AliT0hit", 405);
95	gAlice->GetMCApp()->AddHitList(fHits);
96	// fDigits = new AliT0digit();
97	// fRecPoints = new AliT0RecPoint();
98	fIshunt = 1;
99	// fIdSens = 0;
100	//PH SetMarkerColor(kRed);
101	}
102
103	//_____________________________________________________________________________
104	AliT0::~AliT0() {
105
106	if (fHits) {
107	fHits->Delete();
108	delete fHits;
109	}
110	/*
111	if (fDigits) {
112	fDigits->Delete();
113	delete fDigits;
114	cout<<" delete fDigits; "<<endl;
115	}
116	if (fRecPoints) {
117	fRecPoints ->Delete();
118	delete fRecPoints;
119	cout<<" delete fRecPoints; "<<endl;
120	}
121	*/
122	}
123
124	//_____________________________________________________________________________
125	void AliT0::AddHit(Int_t track, Int_t vol, Float_t hits)
126	{
127	//
128	// Add a T0 hit
129	//
130	TClonesArray &lhits = *fHits;
131	new(lhits[fNhits++]) AliT0hit(fIshunt,track,vol,hits);
132	}
133
134
135	//_____________________________________________________________________________
136
137	void AliT0::AddDigit(Int_t besttimeright, Int_t besttimeleft, Int_t meantime,
138	Int_t timediff, Int_t sumMult,
139	TArrayI time, TArrayI adc, TArrayI timeAmp, TArrayI adcAmp)
140	{
141
142	// Add a T0 digit to the list.
143	//
144
145	if (!fDigits) {
146	fDigits = new AliT0digit();
147	}
148	fDigits-> SetTimeBestRight(besttimeright);
149	fDigits->SetTimeBestLeft(besttimeleft);
150	fDigits-> SetMeanTime(meantime);
151	fDigits-> SetDiffTime(timediff);
152	fDigits-> SetSumMult(sumMult);
153	fDigits->SetTime(*time);
154	fDigits->SetTimeAmp(*timeAmp);
155	fDigits->SetADC(*adc);
156	fDigits->SetADCAmp(*adcAmp);
157	}
158
159
160	//_____________________________________________________________________________
161	void AliT0::BuildGeometry()
162	{
163	//
164	// Build simple ROOT TNode geometry for event display
165	//
166	TNode node, top;
167	const int kColorT0 = 19;
168
169	top=gAlice->GetGeometry()->GetNode("alice");
170
171	// T0 define the different volumes
172	new TRotMatrix("rotx999","rot999", 90,0,90,90,180,0);
173
174	new TTUBE("S_0ST1","T0 volume 1","void",5.,10.7,5.3);
175	top->cd();
176	node = new TNode("0ST1","0ST01","S_0ST1",0,0,-69.7,"");
177	node->SetLineColor(kColorT0);
178	fNodes->Add(node);
179
180	new TTUBE("S_0ST2","T0 volume 2","void",5.,10.7,5.3);
181	top->cd();
182	node = new TNode("0ST2","0ST2","S_0ST2",0,0,350,"rotx999");
183	node->SetLineColor(kColorT0);
184	fNodes->Add(node);
185	}
186
187	//_____________________________________________________________________________
188	Int_t AliT0::DistanceToPrimitive(Int_t /px/, Int_t /py/)
189	{
190	//
191	// Calculate the distance from the mouse to the T0 on the screen
192	// Dummy routine
193	//
194	return 9999;
195	}
196
197	//-------------------------------------------------------------------------
198	void AliT0::Init()
199	{
200	//
201	// Initialis the T0 after it has been built
202	Int_t i;
203	//
204	if(AliLog::GetGlobalDebugLevel()>0) {
205	printf("\n%s: ",ClassName());
206	for(i=0;i<35;i++) printf("*");
207	printf(" T0_INIT ");
208	for(i=0;i<35;i++) printf("*");
209	printf("\n%s: ",ClassName());
210	//
211	// Here the T0 initialisation code (if any!)
212	for(i=0;i<80;i++) printf("*");
213	printf("\n");
214	}
215	}
216
217	//---------------------------------------------------------------------------
218	void AliT0::MakeBranch(Option_t* option)
219	{
220	//
221	// Create Tree branches for the T0.
222
223	// Options:
224	//
225	// H Make a branch of TClonesArray of AliT0Hit's
226	// D Make a branch of TClonesArray of AliT0Digit's
227	//
228	// R Make a branch of AliT0RecPoints
229	//
230	char branchname[20];
231	sprintf(branchname,"%s",GetName());
232
233	const char *cH = strstr(option,"H");
234	const char *cD = strstr(option,"D");
235	const char *cR = strstr(option,"R");
236
237	if (cH && fLoader->TreeH())
238	{
239	if (fHits == 0x0) fHits = new TClonesArray("AliT0hit", 405);
240	AliDetector::MakeBranch(option);
241	}
242
243
244	if (cD && fLoader->TreeD())
245	{
246	if (fDigits == 0x0) fDigits = new AliT0digit();
247	// MakeBranchInTree(fLoader->TreeD(), branchname,
248	// &fDigits, 405, 0);
249	fLoader->TreeD()->Branch(branchname,"AliT0digit",&fDigits,405,1);
250	// fLoader->TreeD()->Print();
251	}
252	if (cR && fLoader->TreeR())
253	{
254	if (fRecPoints == 0x0) fRecPoints = new AliT0RecPoint();
255	MakeBranchInTree(fLoader->TreeR(), branchname,
256	&fRecPoints, 405, 0);
257	}
258
259	}
260
261	//_____________________________________________________________________________
262	void AliT0::ResetHits()
263	{
264	AliDetector::ResetHits();
265
266	}
267	//____________________________________________________________________
268	void AliT0::ResetDigits()
269	{
270	//
271	// Reset number of digits and the digits array for this detector
272	//
273	if (fDigits) fDigits->Clear();
274	}
275
276	//_____________________________________________________________________________
277	void AliT0::SetTreeAddress()
278	{
279
280	TTree *treeH;
281	treeH = TreeH();
282
283	if (treeH)
284	{
285	if (fHits == 0x0) fHits = new TClonesArray("AliT0hit", 405);
286	}
287
288	AliDetector::SetTreeAddress();
289	TTree *treeD = fLoader->TreeD();
290	if (treeD) {
291	if (fDigits == 0x0) fDigits = new AliT0digit();
292	TBranch* branch = treeD->GetBranch ("T0");
293	if (branch) branch->SetAddress(&fDigits);
294	}
295
296	TTree *treeR = fLoader->TreeR();
297	if (treeR) {
298	if (fRecPoints == 0x0) fRecPoints = new AliT0RecPoint() ;
299	TBranch* branch = treeR->GetBranch ("T0");
300	if (branch) branch->SetAddress(&fRecPoints);
301	}
302
303	}
304
305
306	//_____________________________________________________________________________
307	void AliT0::MakeBranchInTreeD(TTree treeD, const char file)
308	{
309	//
310	// Create TreeD branches for the FMD
311	//
312	const Int_t kBufferSize = 4000;
313	char branchname[20];
314	sprintf(branchname,"%s",GetName());
315	if(treeD)
316	{
317	MakeBranchInTree(treeD, branchname,&fDigits, kBufferSize, file);
318	}
319	}
320
321	//_____________________________________________________________________________
322	AliDigitizer* AliT0::CreateDigitizer(AliRunDigitizer* manager) const
323	{
324	return new AliT0Digitizer(manager);
325	}
326	//____________________________________________________________________________
327	void AliT0::Digits2Raw()
328	{
329	//
330	// Starting from the T0 digits, writes the Raw Data objects
331	//
332	// AliT0Loader* pStartLoader = (AliT0Loader*)fLoader;
333	fLoader ->LoadDigits("read");
334	TTree* treeD = fLoader->TreeD();
335	if (!treeD) {
336	AliError("no digits tree");
337	return;
338	}
339	if (fDigits == 0x0) fDigits = new AliT0digit();
340
341	TBranch *branch = treeD->GetBranch("T0");
342	if (branch) {
343	branch->SetAddress(&fDigits);
344	}else{
345	AliError("Branch T0 DIGIT not found");
346	exit(111);
347	}
348	AliT0RawData rawWriter;
349	rawWriter.SetVerbose(0);
350
351	AliDebug(2,Form(" Formatting raw data for T0 "));
352	branch->GetEntry(0);
353	// rawWriter.RawDataT0(treeD->GetBranch("T0"));
354	rawWriter.RawDataT0(fDigits);
355
356
357	fLoader->UnloadDigits();
358
359	}