/**************************************************************************
* 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$ */
//////////////////////////////////////////////////////////////////////////////
//
// Forward Multiplicity Detector based on Silicon wafers This class
// contains the base procedures for the Forward Multiplicity detector
// Detector consists of 5 Si volumes covered pseudorapidity interval
// from 1.7 to 5.1.
//
// The actual code is done by various separate classes. Below is
// diagram showing the relationship between the various FMD classes
// that handles the geometry
//
//
// +----------+ +----------+
// | AliFMDv1 | | AliFMDv1 |
// +----------+ +----------+
// | |
// +----+--------------+
// |
// | +------------+ 1 +---------------+
// | +- | AliFMDRing |<>--| AliFMDPolygon |
// V 2 | +------------+ +---------------+
// +--------+<>--+ |
// | AliFMD | ^
// +--------+<>--+ V 1..2
// 3 | +-------------------+
// +-| AliFMDSubDetector |
// +-------------------+
// ^
// |
// +-------------+-------------+
// | | |
// +---------+ +---------+ +---------+
// | AliFMD1 | | AliFMD2 | | AliFMD3 |
// +---------+ +---------+ +---------+
//
//
// * AliFMD
// This defines the interface for the various parts of AliROOT that
// uses the FMD, like AliFMDDigitizer, AliFMDReconstructor, and so
// on.
//
// * AliFMDv1
// This is a concrete implementation of the AliFMD interface.
// It is the responsibility of this class to create the FMD
// geometry, process hits in the FMD, and serve hits and digits to
// the various clients.
//
// It uses the objects of class AliFMDSubDetector to do the various
// stuff for FMD1, 2, and 3
//
// * AliFMDRing
// This class contains all stuff needed to do with a ring. It's
// used by the AliFMDSubDetector objects to instantise inner and
// outer rings. The AliFMDRing objects are shared by the
// AliFMDSubDetector objects, and owned by the AliFMDv1 object.
//
// * AliFMDPolygon
// The code I lifted from TGeoPolygon to help with the geometry of
// the modules, as well as to decide wether a hit is actually with
// in the real module shape. The point is, that the shape of the
// various ring modules are really polygons (much like the lid of a
// coffin), but it's segmented at constant radius. That is very
// hard to implement using GEANT 3.21 shapes, so instead the
// modules are implemented as TUBS (tube sections), and in the step
// procedure we do the test whether the track was inside the real
// shape of the module.
//
// * AliFMD1, AliFMD2, and AliFMD3
// These are specialisation of AliFMDSubDetector, that contains the
// particularities of each of the sub-detector system. It is
// envisioned that the classes should also define the support
// volumes and material for each of the detectors.
//
//Begin_Html
/*
The responsible person for this module is
Alla Maevskaia.
Many modifications by Christian
Holm Christensen.
*/
//End_Html
#ifndef ROOT_TClonesArray
#include
#endif
#ifndef ROOT_TGeomtry
# include
#endif
#ifndef ROOT_TNode
# include
#endif
#ifndef ROOT_TTUBE
# include
#endif
#ifndef ROOT_TTree
# include
#endif
#ifndef ROOT_TVirtualMC
# include
#endif
#ifndef ROOT_TBrowser
# include
#endif
#ifndef ROOT_TMath
# include
#endif
#ifndef ALIRUNDIGITIZER_H
# include "AliRunDigitizer.h"
#endif
#ifndef ALILOADER_H
# include "AliLoader.h"
#endif
#ifndef ALIRUN_H
# include "AliRun.h"
#endif
#ifndef ALIMC_H
# include "AliMC.h"
#endif
#ifndef ALILog_H
# include "AliLog.h"
#endif
#ifndef ALIMAGF_H
# include "AliMagF.h"
#endif
#ifndef ALIFMD_H
# include "AliFMD.h"
#endif
#ifndef ALIFMDDIGIG_H
# include "AliFMDDigit.h"
#endif
#ifndef ALIFMDHIT_H
# include "AliFMDHit.h"
#endif
#ifndef ALIFMDDIGITIZER_H
# include "AliFMDDigitizer.h"
#endif
#ifndef ALIFMD1_H
# include "AliFMD1.h"
#endif
#ifndef ALIFMD2_H
# include "AliFMD2.h"
#endif
#ifndef ALIFMD3_H
# include "AliFMD3.h"
#endif
#ifndef ALIALTROBUFFER_H
# include "AliAltroBuffer.h"
#endif
//____________________________________________________________________
ClassImp(AliFMD);
//____________________________________________________________________
AliFMD::AliFMD()
: fInner(0),
fOuter(0),
fFMD1(0),
fFMD2(0),
fFMD3(0)
{
//
// Default constructor for class AliFMD
//
AliDebug(0, "Default CTOR");
fHits = 0;
fDigits = 0;
fSDigits = 0;
fNsdigits = 0;
fIshunt = 0;
}
//____________________________________________________________________
AliFMD::AliFMD(const char *name, const char *title, bool detailed)
: AliDetector (name, title),
fInner(0),
fOuter(0),
fFMD1(0),
fFMD2(0),
fFMD3(0)
{
//
// Standard constructor for Forward Multiplicity Detector
//
AliDebug(0, "Standard CTOR");
// Initialise Hit array
HitsArray();
gAlice->GetMCApp()->AddHitList(fHits);
// (S)Digits for the detectors disk
DigitsArray();
SDigitsArray();
// CHC: What is this?
fIshunt = 0;
SetMarkerColor(kRed);
SetLineColor(kYellow);
SetSiDensity();
// Create sub-volume managers
fInner = new AliFMDRing('I', detailed);
fOuter = new AliFMDRing('O', detailed);
fFMD1 = new AliFMD1();
fFMD2 = new AliFMD2();
fFMD3 = new AliFMD3();
// Specify parameters of sub-volume managers
fFMD1->SetInner(fInner);
fFMD1->SetOuter(0);
fFMD2->SetInner(fInner);
fFMD2->SetOuter(fOuter);
fFMD3->SetInner(fInner);
fFMD3->SetOuter(fOuter);
SetLegLength();
SetLegRadius();
SetLegOffset();
SetModuleSpacing();
fInner->SetLowR(4.3);
fInner->SetHighR(17.2);
fInner->SetWaferRadius(13.4/2);
fInner->SetTheta(36/2);
fInner->SetNStrips(512);
fInner->SetSiThickness(.03);
fInner->SetPrintboardThickness(.11);
fInner->SetBondingWidth(.5);
fOuter->SetLowR(15.6);
fOuter->SetHighR(28.0);
fOuter->SetWaferRadius(13.4/2);
fOuter->SetTheta(18/2);
fOuter->SetNStrips( 256);
fOuter->SetSiThickness(.03);
fOuter->SetPrintboardThickness(.1);
fOuter->SetBondingWidth(.5);
fFMD1->SetHoneycombThickness(1);
fFMD1->SetInnerZ(340.0);
fFMD2->SetHoneycombThickness(1);
fFMD2->SetInnerZ(83.4);
fFMD2->SetOuterZ(75.2);
fFMD3->SetHoneycombThickness(1);
fFMD3->SetInnerZ(-62.8);
fFMD3->SetOuterZ(-75.2);
}
//____________________________________________________________________
AliFMD::~AliFMD ()
{
// Destructor for base class AliFMD
if (fHits) {
fHits->Delete();
delete fHits;
fHits = 0;
}
if (fDigits) {
fDigits->Delete();
delete fDigits;
fDigits = 0;
}
if (fSDigits) {
fSDigits->Delete();
delete fSDigits;
fSDigits = 0;
}
}
//====================================================================
//
// GEometry ANd Traking
//
//____________________________________________________________________
void
AliFMD::CreateGeometry()
{
//
// Create the geometry of Forward Multiplicity Detector version 0
//
// DebugGuard guard("AliFMD::CreateGeometry");
AliDebug(10, "Creating geometry");
fInner->Init();
fOuter->Init();
TString name;
Double_t par[3];
par[0] = fLegRadius - .1;
par[1] = fLegRadius;
par[2] = fLegLength / 2;
name = "SLEG";
fShortLegId = gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
par[2] += fModuleSpacing / 2;
name = "LLEG";
fLongLegId = gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
fInner->SetupGeometry((*fIdtmed)[kAirId],
(*fIdtmed)[kSiId],
(*fIdtmed)[kPcbId],
fPrintboardRotationId,
fIdentityRotationId);
fOuter->SetupGeometry((*fIdtmed)[kAirId],
(*fIdtmed)[kSiId],
(*fIdtmed)[kPcbId],
fPrintboardRotationId,
fIdentityRotationId);
fFMD1->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
fFMD2->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
fFMD3->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
fFMD1->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
fFMD2->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
fFMD3->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
}
//____________________________________________________________________
void AliFMD::CreateMaterials()
{
// Register various materials and tracking mediums with the
// backend.
//
// Currently defined materials and mediums are
//
// FMD Air Normal air
// FMD Si Active silicon of sensors
// FMD Carbon Normal carbon used in support, etc.
// FMD Kapton Carbon used in Honeycomb
// FMD PCB Printed circuit board material
// FMD Plastic Material for support legs
//
// Also defined are two rotation matricies.
//
// DebugGuard guard("AliFMD::CreateMaterials");
AliDebug(10, "Creating materials");
Int_t id;
Double_t a = 0;
Double_t z = 0;
Double_t density = 0;
Double_t radiationLength = 0;
Double_t absorbtionLength = 999;
Int_t fieldType = gAlice->Field()->Integ(); // Field type
Double_t maxField = gAlice->Field()->Max(); // Field max.
Double_t maxBending = 0; // Max Angle
Double_t maxStepSize = 0.001; // Max step size
Double_t maxEnergyLoss = 1; // Max Delta E
Double_t precision = 0.001; // Precision
Double_t minStepSize = 0.001; // Minimum step size
// Silicon
a = 28.0855;
z = 14.;
density = fSiDensity;
radiationLength = 9.36;
maxBending = 1;
maxStepSize = .001;
precision = .001;
minStepSize = .001;
id = kSiId;
AliMaterial(id, "FMD Si$", a, z, density, radiationLength, absorbtionLength);
AliMedium(kSiId, "FMD Si$",id,1,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
// Carbon
a = 12.011;
z = 6.;
density = 2.265;
radiationLength = 18.8;
maxBending = 10;
maxStepSize = .01;
precision = .003;
minStepSize = .003;
id = kCarbonId;
AliMaterial(id, "FMD Carbon$", a, z, density, radiationLength,
absorbtionLength);
AliMedium(kCarbonId, "FMD Carbon$",id,0,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
// Silicon chip
{
Float_t as[] = { 12.0107, 14.0067, 15.9994,
1.00794, 28.0855, 107.8682 };
Float_t zs[] = { 6., 7., 8.,
1., 14., 47. };
Float_t ws[] = { 0.039730642, 0.001396798, 0.01169634,
0.004367771, 0.844665, 0.09814344903 };
density = 2.36436;
maxBending = 10;
maxStepSize = .01;
precision = .003;
minStepSize = .003;
id = kSiChipId;
AliMixture(id, "FMD Si Chip$", as, zs, density, 6, ws);
AliMedium(kSiChipId, "FMD Si Chip$", id, 0, fieldType, maxField,
maxBending, maxStepSize, maxEnergyLoss, precision, minStepSize);
}
// Kaption
{
Float_t as[] = { 1.00794, 12.0107, 14.010, 15.9994};
Float_t zs[] = { 1., 6., 7., 8.};
Float_t ws[] = { 0.026362, 0.69113, 0.07327, 0.209235};
density = 1.42;
maxBending = 1;
maxStepSize = .001;
precision = .001;
minStepSize = .001;
id = kKaptionId;
AliMixture(id, "FMD Kaption$", as, zs, density, 4, ws);
AliMedium(kKaptionId, "FMD Kaption$",id,0,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
}
// Air
{
Float_t as[] = { 12.0107, 14.0067, 15.9994, 39.948 };
Float_t zs[] = { 6., 7., 8., 18. };
Float_t ws[] = { 0.000124, 0.755267, 0.231781, 0.012827 };
density = .00120479;
maxBending = 1;
maxStepSize = .001;
precision = .001;
minStepSize = .001;
id = kAirId;
AliMixture(id, "FMD Air$", as, zs, density, 4, ws);
AliMedium(kAirId, "FMD Air$", id,0,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
}
// PCB
{
Float_t zs[] = { 14., 20., 13., 12.,
5., 22., 11., 19.,
26., 9., 8., 6.,
7., 1.};
Float_t as[] = { 28.0855, 40.078, 26.981538, 24.305,
10.811, 47.867, 22.98977, 39.0983,
55.845, 18.9984, 15.9994, 12.0107,
14.0067, 1.00794};
Float_t ws[] = { 0.15144894, 0.08147477, 0.04128158, 0.00904554,
0.01397570, 0.00287685, 0.00445114, 0.00498089,
0.00209828, 0.00420000, 0.36043788, 0.27529426,
0.01415852, 0.03427566};
density = 1.8;
maxBending = 1;
maxStepSize = .001;
precision = .001;
minStepSize = .001;
id = kPcbId;
AliMixture(id, "FMD PCB$", as, zs, density, 14, ws);
AliMedium(kPcbId, "FMD PCB$", id,1,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
}
// Plastic
{
Float_t as[] = { 1.01, 12.01 };
Float_t zs[] = { 1., 6. };
Float_t ws[] = { 1., 1. };
density = 1.03;
maxBending = 10;
maxStepSize = .01;
precision = .003;
minStepSize = .003;
id = kPlasticId;
AliMixture(id, "FMD Plastic$", as, zs, density, -2, ws);
AliMedium(kPlasticId, "FMD Plastic$", id,0,fieldType,maxField,maxBending,
maxStepSize,maxEnergyLoss,precision,minStepSize);
}
AliMatrix(fPrintboardRotationId, 90, 90, 0, 90, 90, 0);
AliMatrix(fIdentityRotationId, 90, 0, 90, 90, 0, 0);
}
//____________________________________________________________________
void
AliFMD::Init()
{
//
// Initialis the FMD after it has been built
Int_t i;
//
if (fDebug) {
std::cout << "\n" << ClassName() << ": " << std::flush;
for (i = 0; i < 35; i++) std::cout << "*";
std::cout << " FMD_INIT ";
for (i = 0; i < 35; i++) std::cout << "*";
std::cout << "\n" << ClassName() << ": " << std::flush;
//
// Here the FMD initialisation code (if any!)
for (i = 0; i < 80; i++) std::cout << "*";
std::cout << std::endl;
}
//
//
}
//====================================================================
//
// Graphics and event display
//
//____________________________________________________________________
void
AliFMD::BuildGeometry()
{
//
// Build simple ROOT TNode geometry for event display
//
// Build a simplified geometry of the FMD used for event display
//
AliDebug(10, "Creating a simplified geometry");
TNode* top = gAlice->GetGeometry()->GetNode("alice");
fFMD1->SimpleGeometry(fNodes, top, GetLineColor(), 0);
fFMD2->SimpleGeometry(fNodes, top, GetLineColor(), 0);
fFMD3->SimpleGeometry(fNodes, top, GetLineColor(), 0);
}
//____________________________________________________________________
void
AliFMD::DrawDetector()
{
//
// Draw a shaded view of the Forward multiplicity detector version 0
//
// DebugGuard guard("AliFMD::DrawDetector");
AliDebug(10, "Draw detector");
//Set ALIC mother transparent
gMC->Gsatt("ALIC","SEEN",0);
//Set volumes visible
fFMD1->Gsatt();
fFMD2->Gsatt();
fFMD3->Gsatt();
fInner->Gsatt();
fOuter->Gsatt();
//
gMC->Gdopt("hide", "on");
gMC->Gdopt("shad", "on");
gMC->Gsatt("*", "fill", 7);
gMC->SetClipBox(".");
gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
gMC->DefaultRange();
gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
gMC->Gdhead(1111, "Forward Multiplicity Detector");
gMC->Gdman(16, 10, "MAN");
gMC->Gdopt("hide", "off");
}
//____________________________________________________________________
const Int_t
AliFMD::DistanceToPrimitive(Int_t, Int_t)
{
//
// Calculate the distance from the mouse to the FMD on the screen
// Dummy routine
//
return 9999;
}
//====================================================================
//
// Hit and Digit managment
//
//____________________________________________________________________
void
AliFMD::MakeBranch(Option_t * option)
{
// Create Tree branches for the FMD.
const Int_t kBufferSize = 16000;
TString branchname(GetName());
TString opt(option);
if (opt.Contains("H", TString::kIgnoreCase)) {
HitsArray();
AliDetector::MakeBranch(option);
}
if (opt.Contains("D", TString::kIgnoreCase)) {
DigitsArray();
MakeBranchInTree(fLoader->TreeD(), branchname.Data(),
&fDigits, kBufferSize, 0);
}
if (opt.Contains("S", TString::kIgnoreCase)) {
SDigitsArray();
MakeBranchInTree(fLoader->TreeS(), branchname.Data(),
&fSDigits, kBufferSize, 0);
}
}
//____________________________________________________________________
void
AliFMD::SetTreeAddress()
{
// Set branch address for the Hits and Digits Tree.
if (fLoader->TreeH()) HitsArray();
AliDetector::SetTreeAddress();
TTree *treeD = fLoader->TreeD();
if (treeD) {
DigitsArray();
TBranch* branch = treeD->GetBranch ("FMD");
if (branch) branch->SetAddress(&fDigits);
}
TTree *treeS = fLoader->TreeS();
if (treeS) {
SDigitsArray();
TBranch* branch = treeS->GetBranch ("FMD");
if (branch) branch->SetAddress(&fSDigits);
}
}
//____________________________________________________________________
void
AliFMD::SetHitsAddressBranch(TBranch *b)
{
b->SetAddress(&fHits);
}
//____________________________________________________________________
void
AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{
// Add a hit to the hits tree
//
// The information of the two arrays are decoded as
//
// Parameters
// track Track #
// ivol[0] [UShort_t ] Detector #
// ivol[1] [Char_t ] Ring ID
// ivol[2] [UShort_t ] Sector #
// ivol[3] [UShort_t ] Strip #
// hits[0] [Float_t ] Track's X-coordinate at hit
// hits[1] [Float_t ] Track's Y-coordinate at hit
// hits[3] [Float_t ] Track's Z-coordinate at hit
// hits[4] [Float_t ] X-component of track's momentum
// hits[5] [Float_t ] Y-component of track's momentum
// hits[6] [Float_t ] Z-component of track's momentum
// hits[7] [Float_t ] Energy deposited by track
// hits[8] [Int_t ] Track's particle Id #
// hits[9] [Float_t ] Time when the track hit
AddHit(track,
UShort_t(vol[0]), // Detector #
Char_t(vol[1]), // Ring ID
UShort_t(vol[2]), // Sector #
UShort_t(vol[3]), // Strip #
hits[0], // X
hits[1], // Y
hits[2], // Z
hits[3], // Px
hits[4], // Py
hits[5], // Pz
hits[6], // Energy loss
Int_t(hits[7]), // PDG
hits[8]); // Time
}
//____________________________________________________________________
void
AliFMD::AddHit(Int_t track,
UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip,
Float_t x,
Float_t y,
Float_t z,
Float_t px,
Float_t py,
Float_t pz,
Float_t edep,
Int_t pdg,
Float_t t)
{
//
// Add a hit to the list
//
// Parameters:
//
// track Track #
// detector Detector # (1, 2, or 3)
// ring Ring ID ('I' or 'O')
// sector Sector # (For inner/outer rings: 0-19/0-39)
// strip Strip # (For inner/outer rings: 0-511/0-255)
// x Track's X-coordinate at hit
// y Track's Y-coordinate at hit
// z Track's Z-coordinate at hit
// px X-component of track's momentum
// py Y-component of track's momentum
// pz Z-component of track's momentum
// edep Energy deposited by track
// pdg Track's particle Id #
// t Time when the track hit
//
TClonesArray& a = *(HitsArray());
// Search through the list of already registered hits, and see if we
// find a hit with the same parameters. If we do, then don't create
// a new hit, but rather update the energy deposited in the hit.
// This is done, so that a FLUKA based simulation will get the
// number of hits right, not just the enerrgy deposition.
for (Int_t i = 0; i < fNhits; i++) {
if (!a.At(i)) continue;
AliFMDHit* hit = static_cast(a.At(i));
if (hit->Detector() == detector
&& hit->Ring() == ring
&& hit->Sector() == sector
&& hit->Strip() == strip
&& hit->Track() == track) {
hit->SetEdep(hit->Edep() + edep);
return;
}
}
// If hit wasn't already registered, do so know.
new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, strip,
x, y, z, px, py, pz, edep, pdg, t);
fNhits++;
}
//____________________________________________________________________
void
AliFMD::AddDigit(Int_t* digits)
{
// Add a digit to the Digit tree
//
// Paramters
//
// digits[0] [UShort_t] Detector #
// digits[1] [Char_t] Ring ID
// digits[2] [UShort_t] Sector #
// digits[3] [UShort_t] Strip #
// digits[4] [UShort_t] ADC Count
// digits[5] [Short_t] ADC Count, -1 if not used
// digits[6] [Short_t] ADC Count, -1 if not used
//
AddDigit(UShort_t(digits[0]), // Detector #
Char_t(digits[1]), // Ring ID
UShort_t(digits[2]), // Sector #
UShort_t(digits[3]), // Strip #
UShort_t(digits[4]), // ADC Count1
Short_t(digits[5]), // ADC Count2
Short_t(digits[6])); // ADC Count3
}
//____________________________________________________________________
void
AliFMD::AddDigit(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip,
UShort_t count1,
Short_t count2,
Short_t count3)
{
// add a real digit - as coming from data
//
// Parameters
//
// detector Detector # (1, 2, or 3)
// ring Ring ID ('I' or 'O')
// sector Sector # (For inner/outer rings: 0-19/0-39)
// strip Strip # (For inner/outer rings: 0-511/0-255)
// count1 ADC count (a 10-bit word)
// count2 ADC count (a 10-bit word), or -1 if not used
// count3 ADC count (a 10-bit word), or -1 if not used
TClonesArray& a = *(DigitsArray());
new (a[fNdigits++])
AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
}
//____________________________________________________________________
void
AliFMD::AddSDigit(Int_t* digits)
{
// Add a digit to the SDigit tree
//
// Paramters
//
// digits[0] [UShort_t] Detector #
// digits[1] [Char_t] Ring ID
// digits[2] [UShort_t] Sector #
// digits[3] [UShort_t] Strip #
// digits[4] [Float_t] Total energy deposited
// digits[5] [UShort_t] ADC Count
// digits[6] [Short_t] ADC Count, -1 if not used
// digits[7] [Short_t] ADC Count, -1 if not used
//
AddSDigit(UShort_t(digits[0]), // Detector #
Char_t(digits[1]), // Ring ID
UShort_t(digits[2]), // Sector #
UShort_t(digits[3]), // Strip #
Float_t(digits[4]), // Edep
UShort_t(digits[5]), // ADC Count1
Short_t(digits[6]), // ADC Count2
Short_t(digits[7])); // ADC Count3
}
//____________________________________________________________________
void
AliFMD::AddSDigit(UShort_t detector,
Char_t ring,
UShort_t sector,
UShort_t strip,
Float_t edep,
UShort_t count1,
Short_t count2,
Short_t count3)
{
// add a summable digit
//
// Parameters
//
// detector Detector # (1, 2, or 3)
// ring Ring ID ('I' or 'O')
// sector Sector # (For inner/outer rings: 0-19/0-39)
// strip Strip # (For inner/outer rings: 0-511/0-255)
// edep Total energy deposited
// count1 ADC count (a 10-bit word)
// count2 ADC count (a 10-bit word), or -1 if not used
// count3 ADC count (a 10-bit word), or -1 if not used
TClonesArray& a = *(SDigitsArray());
new (a[fNsdigits++])
AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
}
//____________________________________________________________________
void
AliFMD::ResetSDigits()
{
//
// Reset number of digits and the digits array for this detector
//
fNsdigits = 0;
if (fSDigits) fSDigits->Clear();
}
//____________________________________________________________________
TClonesArray*
AliFMD::HitsArray()
{
// Initialize hit array if not already, and return pointer to it.
if (!fHits) {
fHits = new TClonesArray("AliFMDHit", 1000);
fNhits = 0;
}
return fHits;
}
//____________________________________________________________________
TClonesArray*
AliFMD::DigitsArray()
{
// Initialize digit array if not already, and return pointer to it.
if (!fDigits) {
fDigits = new TClonesArray("AliFMDDigit", 1000);
fNdigits = 0;
}
return fDigits;
}
//____________________________________________________________________
TClonesArray*
AliFMD::SDigitsArray()
{
// Initialize digit array if not already, and return pointer to it.
if (!fSDigits) {
fSDigits = new TClonesArray("AliFMDSDigit", 1000);
fNsdigits = 0;
}
return fSDigits;
}
//====================================================================
//
// Digitization
//
//____________________________________________________________________
void
AliFMD::Hits2Digits()
{
AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
manager->SetInputStream(0, "galice.root");
manager->SetOutputFile("H2Dfile");
/* AliDigitizer* dig =*/ CreateDigitizer(manager);
manager->Exec("");
}
//____________________________________________________________________
void
AliFMD::Hits2SDigits()
{
AliDigitizer* sdig = new AliFMDSDigitizer("galice.root");
sdig->Exec("");
}
//____________________________________________________________________
AliDigitizer*
AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
{
// Create a digitizer object
return new AliFMDDigitizer(manager);
}
//====================================================================
//
// Raw data simulation
//
//__________________________________________________________________
void
AliFMD::Digits2Raw()
{
AliFMD* fmd = static_cast(gAlice->GetDetector(GetName()));
fLoader->LoadDigits();
TTree* digitTree = fLoader->TreeD();
if (!digitTree) {
Error("Digits2Raw", "no digit tree");
return;
}
TClonesArray* digits = new TClonesArray("AliFMDDigit", 1000);
fmd->SetTreeAddress();
TBranch* digitBranch = digitTree->GetBranch(GetName());
if (!digitBranch) {
Error("Digits2Raw", "no branch for %s", GetName());
return;
}
digitBranch->SetAddress(&digits);
Int_t nEvents = (Int_t)digitTree->GetEntries();
for (Int_t event = 0; event < nEvents; event++) {
fmd->ResetDigits();
digitTree->GetEvent(event);
Int_t nDigits = digits->GetEntries();
if (nDigits < 1) continue;
UShort_t prevDetector = 0;
Char_t prevRing = '\0';
UShort_t prevSector = 0;
// UShort_t prevStrip = 0;
// The first seen strip number for a channel
UShort_t startStrip = 0;
// Which channel number in the ALTRO channel we're at
UShort_t offset = 0;
// How many times the ALTRO Samples one VA1_ALICE channel
Int_t sampleRate = 1;
// A buffer to hold 1 ALTRO channel - Normally, one ALTRO channel
// holds 128 VA1_ALICE channels, sampled at a rate of `sampleRate'
TArrayI channel(128 * sampleRate);
// The Altro buffer
AliAltroBuffer* altro = 0;
// Loop over the digits in the event. Note, that we assume the
// the digits are in order in the branch. If they were not, we'd
// have to cache all channels before we could write the data to
// the ALTRO buffer, or we'd have to set up a map of the digits.
for (Int_t i = 0; i < nDigits; i++) {
// Get the digit
AliFMDDigit* digit = static_cast(digits->At(i));
UShort_t det = digit->Detector();
Char_t ring = digit->Ring();
UShort_t sector = digit->Sector();
UShort_t strip = digit->Strip();
if (det != prevDetector) {
AliDebug(10, Form("FMD: New DDL, was %d, now %d",
kBaseDDL + prevDetector - 1,
kBaseDDL + det - 1));
// If an altro exists, delete the object, flushing the data to
// disk, and closing the file.
if (altro) {
// When the first argument is false, we write the real
// header.
AliDebug(10, Form("New altro: Write channel at %d Strip: %d "
"Sector: %d Ring: %d",
i, startStrip, prevSector, prevRing));
// TPC to FMD translations
//
// TPC FMD
// ----------+-----------
// pad | strip
// row | sector
// sector | ring
//
altro->WriteChannel(Int_t(startStrip),
Int_t(prevSector),
Int_t((prevRing == 'I' ? 0 : 1)),
channel.fN, channel.fArray, 0);
altro->Flush();
altro->WriteDataHeader(kFALSE, kFALSE);
delete altro;
altro = 0;
}
prevDetector = det;
// Need to open a new DDL!
Int_t ddlId = kBaseDDL + det - 1;
TString filename(Form("%s_%d.ddl", GetName(), ddlId));
AliDebug(10, Form("New altro buffer with DDL file %s",
filename.Data()));
AliDebug(10, Form("New altro at %d", i));
// Create a new altro buffer - a `1' as the second argument
// means `write mode'
altro = new AliAltroBuffer(filename.Data(), 1);
// Write a dummy (first argument is true) header to the DDL
// file - later on, when we close the file, we write the real
// header
altro->WriteDataHeader(kTRUE, kFALSE);
// Figure out the sample rate
if (digit->Count2() > 0) sampleRate = 2;
if (digit->Count3() > 0) sampleRate = 3;
channel.Set(128 * sampleRate);
offset = 0;
prevRing = ring;
prevSector = sector;
startStrip = strip;
}
else if (offset == 128
|| digit->Ring() != prevRing
|| digit->Sector() != prevSector) {
// Force a new Altro channel
AliDebug(10, Form("Flushing channel to disk because %s",
(offset == 128 ? "channel is full" :
(ring != prevRing ? "new ring up" :
"new sector up"))));
AliDebug(10, Form("New Channel: Write channel at %d Strip: %d "
"Sector: %d Ring: %d",
i, startStrip, prevSector, prevRing));
altro->WriteChannel(Int_t(startStrip),
Int_t(prevSector),
Int_t((prevRing == 'I' ? 0 : 1)),
channel.fN, channel.fArray, 0);
// Reset and update channel variables
channel.Reset(0);
offset = 0;
startStrip = strip;
prevRing = ring;
prevSector = sector;
}
// Store the counts of the ADC in the channel buffer
channel[offset * sampleRate] = digit->Count1();
if (sampleRate > 1)
channel[offset * sampleRate + 1] = digit->Count2();
if (sampleRate > 2)
channel[offset * sampleRate + 2] = digit->Count3();
offset++;
}
// Finally, we need to close the final ALTRO buffer if it wasn't
// already
if (altro) {
altro->Flush();
altro->WriteDataHeader(kFALSE, kFALSE);
delete altro;
}
}
fLoader->UnloadDigits();
}
//==================================================================
//
// Various setter functions for the common paramters
//
//__________________________________________________________________
void
AliFMD::SetLegLength(Double_t length)
{
// Set lenght of plastic legs that hold the hybrid (print board and
// silicon sensor) onto the honeycomp support
//
// DebugGuard guard("AliFMD::SetLegLength");
AliDebug(10, "AliFMD::SetLegLength");
fLegLength = length;
fInner->SetLegLength(fLegLength);
fOuter->SetLegLength(fLegLength);
}
//__________________________________________________________________
void
AliFMD::SetLegOffset(Double_t offset)
{
// Set offset from edge of hybrid to plastic legs that hold the
// hybrid (print board and silicon sensor) onto the honeycomp
// support
//
// DebugGuard guard("AliFMD::SetLegOffset");
AliDebug(10, "AliFMD::SetLegOffset");
fInner->SetLegOffset(offset);
fOuter->SetLegOffset(offset);
}
//__________________________________________________________________
void
AliFMD::SetLegRadius(Double_t radius)
{
// Set the diameter of the plastic legs that hold the hybrid (print
// board and silicon sensor) onto the honeycomp support
//
// DebugGuard guard("AliFMD::SetLegRadius");
AliDebug(10, "AliFMD::SetLegRadius");
fLegRadius = radius;
fInner->SetLegRadius(fLegRadius);
fOuter->SetLegRadius(fLegRadius);
}
//__________________________________________________________________
void
AliFMD::SetModuleSpacing(Double_t spacing)
{
// Set the distance between the front and back sensor modules
// (module staggering).
//
// DebugGuard guard("AliFMD::SetModuleSpacing");
AliDebug(10, "AliFMD::SetModuleSpacing");
fModuleSpacing = spacing;
fInner->SetModuleSpacing(fModuleSpacing);
fOuter->SetModuleSpacing(fModuleSpacing);
}
//====================================================================
//
// Utility
//
//__________________________________________________________________
void
AliFMD::Browse(TBrowser* b)
{
AliDebug(10, "AliFMD::Browse");
AliDetector::Browse(b);
if (fInner) b->Add(fInner, "Inner Ring");
if (fOuter) b->Add(fOuter, "Outer Ring");
if (fFMD1) b->Add(fFMD1, "FMD1 SubDetector");
if (fFMD2) b->Add(fFMD2, "FMD2 SubDetector");
if (fFMD3) b->Add(fFMD3, "FMD3 SubDetector");
}
//********************************************************************
//
// AliFMDv0
//
//__________________________________________________________________
ClassImp(AliFMDv0);
//********************************************************************
//
// AliFMDv1
//
//__________________________________________________________________
ClassImp(AliFMDv1);
//_//____________________________________________________________________
void
AliFMDv1::StepManager()
{
//
// Called for every step in the Forward Multiplicity Detector
//
// The procedure is as follows:
//
// - IF NOT track is alive THEN RETURN ENDIF
// - IF NOT particle is charged THEN RETURN ENDIF
// - IF NOT volume name is "STRI" or "STRO" THEN RETURN ENDIF
// - Get strip number (volume copy # minus 1)
// - Get phi division number (mother volume copy #)
// - Get module number (grand-mother volume copy #)
// - section # = 2 * module # + phi division # - 1
// - Get ring Id from volume name
// - Get detector # from grand-grand-grand-mother volume name
// - Get pointer to sub-detector object.
// - Get track position
// - IF track is entering volume AND track is inside real shape THEN
// - Reset energy deposited
// - Get track momentum
// - Get particle ID #
/// - ENDIF
// - IF track is inside volume AND inside real shape THEN
/// - Update energy deposited
// - ENDIF
// - IF track is inside real shape AND (track is leaving volume,
// or it died, or it is stopped THEN
// - Create a hit
// - ENDIF
//
//
// DebugGuard guard("AliFMDv1::StepManager");
AliDebug(10, "AliFMDv1::StepManager");
// return;
// If the track is gone, return
if (!gMC->IsTrackAlive()) return;
// Only process charged particles
if(TMath::Abs(gMC->TrackCharge()) <= 0) return;
// Only do stuff is the track is in one of the strips.
TString vol(gMC->CurrentVolName());
if (!vol.Contains("STR")) return;
// Get the strip number. Note, that GEANT numbers divisions from 1,
// so we subtract one
Int_t strip;
gMC->CurrentVolID(strip);
strip--;
// Get the phi division of the module
Int_t phiDiv; // * The phi division number (1 or 2)
gMC->CurrentVolOffID(1, phiDiv); // in the module
// Active volume number - not used.
// Int_t active;
// gMC->CurrentVolOffID(2, active);
// Get the module number in the ring.
Int_t module;
gMC->CurrentVolOffID(3, module);
// Ring copy number - the same as the detector number - not used
// Int_t ringCopy; // * Ring copy number
// gMC->CurrentVolOffID(4, ringCopy); // Same as detector number
// Get the detector number from the path name
Int_t detector = Int_t((gMC->CurrentVolOffName(5)[3]) - 48);
// The sector number, calculated from module and phi division #
Int_t sector = 2 * module + phiDiv - 1;
// The ring ID is encoded in the volume name
Char_t ring = vol[3];
// Get a pointer to the sub detector structure
AliFMDSubDetector* det = 0;
switch (detector) {
case 1: det = fFMD1; break;
case 2: det = fFMD2; break;
case 3: det = fFMD3; break;
}
if (!det) return;
// Get the current track position
TLorentzVector v;
gMC->TrackPosition(v);
// Check that the track is actually within the active area
Bool_t isWithin = det->CheckHit(ring, module, v.X(), v.Y());
Bool_t entering = gMC->IsTrackEntering() && isWithin;
Bool_t inside = gMC->IsTrackInside() && isWithin;
Bool_t out = (gMC->IsTrackExiting()
|| gMC->IsTrackDisappeared()
|| gMC->IsTrackStop()
|| !isWithin);
// Reset the energy deposition for this track, and update some of
// our parameters.
if (entering) {
fCurrentDeltaE = 0;
// Get production vertex and momentum of the track
fCurrentV = v;
gMC->TrackMomentum(fCurrentP);
fCurrentPdg = gMC->IdFromPDG(gMC->TrackPid());
// if (fAnalyser)
// fAnalyser->Update(detector, ring, isWithin, v.X(), v.Y());
}
// If the track is inside, then update the energy deposition
if (inside && fCurrentDeltaE >= 0)
fCurrentDeltaE += 1000 * gMC->Edep();
// The track exits the volume, or it disappeared in the volume, or
// the track is stopped because it no longer fulfills the cuts
// defined, then we create a hit.
if (out && fCurrentDeltaE >= 0) {
fCurrentDeltaE += 1000 * gMC->Edep();
AddHit(gAlice->GetMCApp()->GetCurrentTrackNumber(),
detector, ring, sector, strip,
fCurrentV.X(), fCurrentV.Y(), fCurrentV.Z(),
fCurrentP.X(), fCurrentP.Y(), fCurrentP.Z(),
fCurrentDeltaE, fCurrentPdg, fCurrentV.T());
fCurrentDeltaE = -1;
}
}
//___________________________________________________________________
//
// EOF
//