-////////////////////////////////////////////////
-// Manager and hits classes for set:MUON //
-////////////////////////////////////////////////
-
-#include <TTUBE.h>
+/**************************************************************************
+ * 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$ */
+
+// ------------------
+// Class AliMUON
+// ------------------
+// AliDetector class for MUON subsystem
+// providing simulation data management
+
+#include "Riostream.h"
+
+#include <AliPDG.h>
+#include <TBRIK.h>
+#include <TCanvas.h>
+#include <TDirectory.h>
+#include <TFile.h>
+#include <TGeometry.h>
+#include <TMinuit.h>
#include <TNode.h>
-#include <TRandom.h>
+#include <TNtuple.h>
+#include <TObjArray.h>
#include <TObject.h>
+#include <TObjectTable.h>
+#include <TPad.h>
+#include <TParticle.h>
+#include <TROOT.h>
+#include <TRandom.h>
+#include <TRotMatrix.h>
+#include <TTUBE.h>
+#include <TTUBE.h>
+#include <TTree.h>
#include <TVector.h>
-#include <TObjArray.h>
+#include <TVirtualMC.h>
-#include "AliMUON.h"
-#include "AliRun.h"
+//#include "AliHeader.h"
+#include "AliLoader.h"
+#include "AliRunDigitizer.h"
#include "AliMC.h"
-#include "iostream.h"
-#include "AliCallf77.h"
-
-// Static variables for the pad-hit iterator routines
-static Int_t sMaxIterPad=0;
-static Int_t sCurIterPad=0;
-
-ClassImp(AliMUON)
-
-//___________________________________________
+#include "AliRun.h"
+#include "AliMUON.h"
+#include "AliMUONChamberTrigger.h"
+#include "AliMUONConstants.h"
+#include "AliMUONHit.h"
+#include "AliMUONRawCluster.h"
+#include "AliMUONTransientDigit.h"
+#include "AliMUONTriggerCircuit.h"
+#include "AliMUONTriggerCircuitNew.h"
+#include "AliMUONGeometry.h"
+#include "AliMUONGeometryTransformer.h"
+#include "AliMUONGeometryBuilder.h"
+#include "AliMUONCommonGeometryBuilder.h"
+#include "AliMUONVGeometryBuilder.h"
+#include "AliMUONGeometrySegmentation.h"
+#include "AliMUONDigitizerv2.h"
+#include "AliMUONSDigitizerv1.h"
+#include "AliMUONRawWriter.h"
+#include "AliMUONSegmentation.h"
+#include "AliLog.h"
+
+#include "AliMUONSDigitizerV2.h"
+#include "AliMUONDigitizerV3.h"
+
+#include "AliMUONSt1GeometryBuilderV2.h"
+#include "AliMUONSt2GeometryBuilderV2.h"
+#include "AliMUONSlatGeometryBuilder.h"
+#include "AliMUONTriggerGeometryBuilder.h"
+
+// Defaults parameters for Z positions of chambers
+// taken from values for "stations" in AliMUON::AliMUON
+// const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
+// and from array "dstation" in AliMUONv1::CreateGeometry
+// Float_t dstation[5]={20., 20., 20, 20., 20.};
+// for tracking chambers,
+// according to (Z1 = zch - dstation) and (Z2 = zch + dstation)
+// for the first and second chambers in the station, respectively,
+// and from "DTPLANES" in AliMUONv1::CreateGeometry
+// const Float_t DTPLANES = 15.;
+// for trigger chambers,
+// according to (Z1 = zch) and (Z2 = zch + DTPLANES)
+// for the first and second chambers in the station, respectively
+
+/// \cond CLASSIMP
+ClassImp(AliMUON)
+/// \endcond
+
+//__________________________________________________________________
AliMUON::AliMUON()
-{
- fIshunt = 0;
- fHits = 0;
- fClusters = 0;
- fNclusters = 0;
- fDchambers = 0;
- fRecClusters= 0;
- fNdch = 0;
-}
-
-//___________________________________________
-AliMUON::AliMUON(const char *name, const char *title)
- : AliDetector(name,title)
-{
-//Begin_Html
-/*
-<img src="picts/alimuon.gif">
-*/
-//End_Html
-
- fHits = new TClonesArray("AliMUONhit",1000 );
- fClusters = new TClonesArray("AliMUONcluster",10000);
- fNclusters = 0;
- fIshunt = 0;
-
- fNdch = new Int_t[11];
-
- fDchambers = new TObjArray(11);
+ : AliDetector(),
+ fNCh(0),
+ fNTrackingCh(0),
+ fMUONData(0),
+ fSplitLevel(0),
+ fChambers(0),
+ fTriggerCircuits(0),
+ fTriggerCircuitsNew(0),
+ fGeometryBuilder(0),
+ fSegmentation(0),
+ fAccCut(kFALSE),
+ fAccMin(0.),
+ fAccMax(0.),
+ fMaxStepGas(0.),
+ fMaxStepAlu(0.),
+ fMaxDestepGas(0.),
+ fMaxDestepAlu(0.),
+ fMaxIterPad(0),
+ fCurIterPad(0),
+ fTriggerScalerEvent(kFALSE),
+ fSDigitizerType(""),
+ fDigitizerType(""),
+ fRawWriter(0x0)
+{
+/// Default Constructor
+
+ AliDebug(1,Form("default (empty) ctor this=%p",this));
+ fIshunt = 0;
+}
+
+//__________________________________________________________________
+AliMUON::AliMUON(const char *name, const char *title,
+ const char* sDigitizerClassName,
+ const char* digitizerClassName)
+ : AliDetector(name,title),
+ fNCh(AliMUONConstants::NCh()),
+ fNTrackingCh(AliMUONConstants::NTrackingCh()),
+ fMUONData(0),
+ fSplitLevel(0),
+ fChambers(0),
+ fTriggerCircuits(0),
+ fTriggerCircuitsNew(0),
+ fGeometryBuilder(0),
+ fSegmentation(0),
+ fAccCut(kFALSE),
+ fAccMin(0.),
+ fAccMax(0.),
+ fMaxStepGas(0.1),
+ fMaxStepAlu(0.1),
+ fMaxDestepGas(-1), // Negatives values are ignored by geant3 CONS200
+ fMaxDestepAlu(-1), // in the calculation of the tracking parameters
+ fMaxIterPad(0),
+ fCurIterPad(0),
+ fTriggerScalerEvent(kFALSE),
+ fSDigitizerType(sDigitizerClassName),
+ fDigitizerType(digitizerClassName),
+ fRawWriter(0x0)
+{
+/// Standard constructor
+
+ AliDebug(1,Form("ctor this=%p",this));
+ fIshunt = 0;
- Int_t i;
-
- for (i=0; i<11 ;i++) {
- (*fDchambers)[i] = new TClonesArray("AliMUONdigit",10000);
- fNdch[i]=0;
- }
+ SetMarkerColor(kRed);//
+
+ // Geometry builder
+ fGeometryBuilder = new AliMUONGeometryBuilder(this);
+
+ // Common geometry definitions
+ fGeometryBuilder
+ ->AddBuilder(new AliMUONCommonGeometryBuilder(this));
+
+ // By default, add also all the needed geometry builders.
+ // If you want to change this from outside, please use ResetGeometryBuilder
+ // method, followed by AddGeometryBuilder ones.
+
+ AddGeometryBuilder(new AliMUONSt1GeometryBuilderV2(this));
+ AddGeometryBuilder(new AliMUONSt2GeometryBuilderV2(this));
+ AddGeometryBuilder(new AliMUONSlatGeometryBuilder(this));
+ AddGeometryBuilder(new AliMUONTriggerGeometryBuilder(this));
+
+ //
+ // Creating List of Chambers
+ Int_t ch;
+ fChambers = new TObjArray(AliMUONConstants::NCh());
+
+ // Loop over stations
+ for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
+ // Loop over 2 chambers in the station
+ for (Int_t stCH = 0; stCH < 2; stCH++) {
+ //
+ //
+ // Default Parameters for Muon Tracking Stations
+ ch = 2 * st + stCH;
+ if (ch < AliMUONConstants::NTrackingCh()) {
+ fChambers->AddAt(new AliMUONChamber(ch),ch);
+ } else {
+ fChambers->AddAt(new AliMUONChamberTrigger(ch, GetGeometryTransformer()),ch);
+ }
+ } // Chamber stCH (0, 1) in
+ } // Station st (0...)
+
+ // cp new design of AliMUONTriggerDecision
+ fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
+ for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
+ fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
+ }
- fRecClusters=new TObjArray(20);
- for (i=0; i<20;i++)
- (*fRecClusters)[i] = new TObjArray(1000);
+ fTriggerCircuitsNew = new TObjArray(AliMUONConstants::NTriggerCircuit());
+ for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
+ fTriggerCircuitsNew->AddAt(new AliMUONTriggerCircuitNew(),circ);
+ }
+
+}
-//
-// Transport angular cut
- fAccCut=0;
- fAccMin=2;
- fAccMax=9;
+//____________________________________________________________________
+AliMUON::AliMUON(const AliMUON& rMUON)
+ : AliDetector(rMUON)
+{
+/// Protected copy constructor
- SetMarkerColor(kRed);
+ AliFatal("Not implemented.");
}
-
-//___________________________________________
+
+//____________________________________________________________________
AliMUON::~AliMUON()
{
+/// Destructor
+
+ AliDebug(1,Form("dtor this=%p",this));
fIshunt = 0;
- delete fHits;
- delete fClusters;
-// for (Int_t i=0;i<10;i++) {
-// delete (*fDchambers)[i];
-// fNdch[i]=0;
-// }
-// delete fDchambers;
- for (Int_t i=0;i<20;i++)
- delete (*fRecClusters)[i];
- delete fRecClusters;
+ if (fChambers){
+ fChambers->Delete();
+ delete fChambers;
+ }
+ if (fTriggerCircuits){
+ fTriggerCircuits->Delete();
+ delete fTriggerCircuits;
+ }
+ if (fTriggerCircuitsNew){
+ fTriggerCircuitsNew->Delete();
+ delete fTriggerCircuitsNew;
+ }
+
+ delete fMUONData;
+ delete fGeometryBuilder;
+ delete fSegmentation;
+ delete fRawWriter;
}
-
-//___________________________________________
-void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
-{
- TClonesArray &lhits = *fHits;
- new(lhits[fNhits++]) AliMUONhit(fIshunt,track,vol,hits);
-}
-//___________________________________________
-void AliMUON::AddCluster(Int_t *clhits)
-{
- TClonesArray &lclusters = *fClusters;
- new(lclusters[fNclusters++]) AliMUONcluster(clhits);
-}
-//_____________________________________________________________________________
-void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
+
+//________________________________________________________________________
+AliMUON& AliMUON::operator = (const AliMUON& rhs)
{
- //
- // Add a MUON digit to the list
- //
+/// Protected assignement operator
- TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
- new(ldigits[fNdch[id]++]) AliMUONdigit(tracks,charges,digits);
-}
+ if (this == &rhs) return *this;
+ AliFatal("Not implemented.");
+
+ return *this;
+}
//_____________________________________________________________________________
-void AliMUON::AddRecCluster(Int_t iCh, Int_t iCat, AliMUONRecCluster* Cluster)
+void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
{
- //
- // Add a MUON reconstructed cluster to the list
- //
- TObjArray* ClusterList = RecClusters(iCh,iCat);
- ClusterList->Add(Cluster);
+/// Add the geometry builder to the list
+
+ fGeometryBuilder->AddBuilder(geomBuilder);
}
-//___________________________________________
+//____________________________________________________________________
void AliMUON::BuildGeometry()
{
- TNode *Node, *Top;
- const int kColorMUON = kBlue;
- //
- Top=gAlice->GetGeometry()->GetNode("alice");
+/// Geometry for event display
- // MUON
- const float cz[10] = { 511, 519, 686, 694, 971, 979, 1245, 1253, 1445, 1453};
- const float acc_min = TMath::Tan( 2*.0174532925199432958);
- const float acc_max = TMath::Tan(9*.0174532925199432958);
- float rmin, rmax;
-
- // Chamber 1
- rmin = (cz[0]+0.25)*acc_min;
- rmax = cz[0]*acc_max;
- new TTUBE("S_MUON1","MUON chamber 1","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON1","MUON chamber 1","S_MUON1",0,0,cz[0],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 2
- rmin = (cz[1]+0.25)*acc_min;
- rmax = cz[1]*acc_max;
- new TTUBE("S_MUON2","MUON chamber 2","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON2","MUON chamber 2","S_MUON2",0,0,cz[1],"");
- fNodes->Add(Node);
- Node->SetLineColor(kColorMUON);
-
- // Chamber 3
- rmin = (cz[2]+0.25)*acc_min;
- rmax = cz[2]*acc_max;
- new TTUBE("S_MUON3","MUON chamber 3","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON3","MUON chamber 3","S_MUON3",0,0,cz[2],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 4
- rmin = (cz[3]+0.25)*acc_min;
- rmax = cz[3]*acc_max;
- new TTUBE("S_MUON4","MUON chamber 4","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON4","MUON chamber 4","S_MUON4",0,0,cz[3],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 5
- rmin = 30;
- rmax = cz[4]*acc_max;
- new TTUBE("S_MUON5","MUON chamber 5","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON5","MUON chamber 5","S_MUON5",0,0,cz[4],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 6
- rmin = 30;
- rmax = cz[5]*acc_max;
- new TTUBE("S_MUON6","MUON chamber 6","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON6","MUON chamber 6","S_MUON6",0,0,cz[5],"");
- fNodes->Add(Node);
- Node->SetLineColor(kColorMUON);
-
- // Chamber 7
- rmin = 30;
- rmax = cz[6]*acc_max;
- new TTUBE("S_MUON7","MUON chamber 7","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON7","MUON chamber 7","S_MUON7",0,0,cz[6],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 8
- rmin = 30;
- rmax = cz[7]*acc_max;
- new TTUBE("S_MUON8","MUON chamber 8","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON8","MUON chamber 8","S_MUON8",0,0,cz[7],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 9
- rmin = 30;
- rmax = cz[8]*acc_max;
- new TTUBE("S_MUON9","MUON chamber 9","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON9","MUON chamber 9","S_MUON9",0,0,cz[8],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
-
- // Chamber 10
- rmin = 30;
- rmax = cz[9]*acc_max;
- new TTUBE("S_MUON10","MUON chamber 10","void",rmin,rmax,0.25);
- Top->cd();
- Node = new TNode("MUON10","MUON chamber 10","S_MUON10",0,0,cz[9],"");
- Node->SetLineColor(kColorMUON);
- fNodes->Add(Node);
+// for (Int_t i = 0; i < AliMUONConstants::NCh(); i++)
+// this->Chamber(i).SegmentationModel2(1)->Draw("eventdisplay");// to be check !
+
+
}
-//___________________________________________
-Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
+//____________________________________________________________________
+const AliMUONGeometry* AliMUON::GetGeometry() const
{
- return 9999;
-}
+/// Return geometry parametrisation
-//___________________________________________
-void AliMUON::MakeBranch(Option_t* option)
-{
- // Create Tree branches for the MUON.
+ if ( !fGeometryBuilder) {
+ AliWarningStream() << "GeometryBuilder not defined." << std::endl;
+ return 0;
+ }
- const Int_t buffersize = 4000;
- char branchname[20];
- sprintf(branchname,"%sCluster",GetName());
-
- AliDetector::MakeBranch(option);
+ return fGeometryBuilder->GetGeometry();
+}
- if (fClusters && gAlice->TreeH()) {
- gAlice->TreeH()->Branch(branchname,&fClusters, buffersize);
- printf("Making Branch %s for clusters\n",branchname);
- }
+//____________________________________________________________________
+const AliMUONGeometryTransformer* AliMUON::GetGeometryTransformer() const
+{
+/// Return geometry parametrisation
-// one branch for digits per chamber
- Int_t i;
+ const AliMUONGeometry* kGeometry = GetGeometry();
- for (i=0; i<10 ;i++) {
- sprintf(branchname,"%sDigits%d",GetName(),i+1);
-
- if (fDchambers && gAlice->TreeD()) {
- gAlice->TreeD()->Branch(branchname,&((*fDchambers)[i]), buffersize);
- printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
- }
- }
-// one branch for rec clusters
- for (i=0; i<20; i++) {
- sprintf(branchname,"%sRecClus%d",GetName(),i+1);
- if (fRecClusters && gAlice->TreeD()) {
- gAlice->TreeR()
- ->Branch(branchname,"TObjArray",
- &((*fRecClusters)[i]), buffersize,0);
- printf("Making Branch %s for clusters in chamber %d\n",
- branchname,i+1);
- }
+ if ( !kGeometry) return 0;
+
+ return kGeometry->GetTransformer();
+}
+
+//__________________________________________________________________
+void AliMUON::SetTreeAddress()
+{
+/// Set Hits tree address
+
+ GetMUONData()->SetLoader(fLoader);
+ // GetMUONData()->MakeBranch("D,S,RC");
+ // GetMUONData()->SetTreeAddress("H,D,S,RC");
+ GetMUONData()->SetTreeAddress("H");
+ if (fHits != GetMUONData()->Hits()) {
+ if ( gAlice->GetMCApp() )
+ if ( gAlice->GetMCApp()->GetHitLists() ) {
+ fHits = GetMUONData()->Hits();
+ gAlice->GetMCApp()->AddHitList(fHits); // For purifyKine, only necessary when Hit list is created in AliMUONData
+ }
}
+ fHits = GetMUONData()->Hits(); // Added by Ivana to use the methods FisrtHit, NextHit of AliDetector
}
-//___________________________________________
-void AliMUON::SetTreeAddress()
+//_________________________________________________________________
+void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
{
- // Set branch address for the Hits and Digits Tree.
- char branchname[20];
- AliDetector::SetTreeAddress();
+/// Set the inverse charge slope for chamber id
- TBranch *branch;
- TTree *treeH = gAlice->TreeH();
- TTree *treeD = gAlice->TreeD();
-
- if (treeH) {
- if (fClusters) {
- branch = treeH->GetBranch("MUONCluster");
- if (branch) branch->SetAddress(&fClusters);
- }
- }
-
- if (treeD) {
- for (int i=0; i<10; i++) {
- sprintf(branchname,"%sDigits%d",GetName(),i+1);
- if (fDchambers) {
- branch = treeD->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fDchambers)[i]));
- }
- }
- }
-}
-//___________________________________________
-void AliMUON::ResetHits()
-{
- // Reset number of clusters and the cluster array for this detector
- AliDetector::ResetHits();
- fNclusters = 0;
- if (fClusters) fClusters->Clear();
+ Int_t i=2*(id-1); //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
+ //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
}
-
-//____________________________________________
-void AliMUON::ResetDigits()
+//__________________________________________________________________
+void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
{
- //
- // Reset number of digits and the digits array for this detector
- //
- for ( int i=0;i<10;i++ ) {
- if ((*fDchambers)[i]) (*fDchambers)[i]->Clear();
- if (fNdch) fNdch[i]=0;
- }
-}
-//____________________________________________
-void AliMUON::ResetRecClusters()
-{
- //
- // Reset the rec clusters
- //
- for ( int i=0;i<20;i++ ) {
- if ((*fRecClusters)[i]) (*fRecClusters)[i]->Clear();
- }
-}
-//___________________________________________
+/// Set sigma of charge spread for chamber id
-void AliMUON::SetPADSIZ(Int_t id, Int_t isec, Float_t p1, Float_t p2)
-{
Int_t i=2*(id-1);
- ((AliMUONchamber*) (*fChambers)[i]) ->SetPADSIZ(isec,p1,p2);
- ((AliMUONchamber*) (*fChambers)[i+1])->SetPADSIZ(isec,p1,p2);
+ ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
}
-
-//___________________________________________
-void AliMUON::SetMUCHSP(Int_t id, Float_t p1)
+//___________________________________________________________________
+void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
{
+/// Set integration limits for charge spread
Int_t i=2*(id-1);
- ((AliMUONchamber*) (*fChambers)[i])->SetMUCHSP(p1);
- ((AliMUONchamber*) (*fChambers)[i+1])->SetMUCHSP(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
}
-//___________________________________________
-void AliMUON::SetMUSIGM(Int_t id, Float_t p1, Float_t p2)
+//__________________________________________________________________
+void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
{
- Int_t i=2*(id-1);
- ((AliMUONchamber*) (*fChambers)[i])->SetMUSIGM(p1,p2);
- ((AliMUONchamber*) (*fChambers)[i+1])->SetMUSIGM(p1,p2);
-}
+/// Set maximum number for ADCcounts (saturation)
-//___________________________________________
-void AliMUON::SetRSIGM(Int_t id, Float_t p1)
-{
Int_t i=2*(id-1);
- ((AliMUONchamber*) (*fChambers)[i])->SetRSIGM(p1);
- ((AliMUONchamber*) (*fChambers)[i+1])->SetRSIGM(p1);
+ ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
+ ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
}
-//___________________________________________
-void AliMUON::SetMAXADC(Int_t id, Float_t p1)
+//__________________________________________________________________
+void AliMUON::SetMaxStepGas(Float_t p1)
{
- Int_t i=2*(id-1);
- ((AliMUONchamber*) (*fChambers)[i])->SetMAXADC(p1);
- ((AliMUONchamber*) (*fChambers)[i+1])->SetMAXADC(p1);
-}
+/// Set stepsize in gas
-//___________________________________________
-void AliMUON::SetSMAXAR(Float_t p1)
-{
- fMaxStepGas=p1;
+ fMaxStepGas=p1;
}
-
-//___________________________________________
-void AliMUON::SetSMAXAL(Float_t p1)
+//__________________________________________________________________
+void AliMUON::SetMaxStepAlu(Float_t p1)
{
+/// Set step size in Alu
+
fMaxStepAlu=p1;
}
-
-//___________________________________________
-void AliMUON::SetDMAXAR(Float_t p1)
+//__________________________________________________________________
+void AliMUON::SetMaxDestepGas(Float_t p1)
{
- fMaxDestepGas=p1;
-}
+/// Set maximum step size in Gas
-//___________________________________________
-void AliMUON::SetDMAXAL(Float_t p1)
-{
- fMaxDestepAlu=p1;
-}
-//___________________________________________
-void AliMUON::SetMUONACC(Bool_t acc, Float_t angmin, Float_t angmax)
-{
- fAccCut=acc;
- fAccMin=angmin;
- fAccMax=angmax;
+ fMaxDestepGas=p1;
}
-//___________________________________________
-void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliMUONsegmentation *segmentation)
+//__________________________________________________________________
+void AliMUON::SetMaxDestepAlu(Float_t p1)
{
- ((AliMUONchamber*) (*fChambers)[id])->SegmentationModel(isec, segmentation);
+/// Set maximum step size in Alu
+ fMaxDestepAlu=p1;
}
-//___________________________________________
-void AliMUON::SetResponseModel(Int_t id, AliMUONresponse *response)
+
+//____________________________________________________________________
+Float_t AliMUON::GetMaxStepGas() const
{
- ((AliMUONchamber*) (*fChambers)[id])->ResponseModel(response);
-}
+/// Return stepsize in gas
+
+ return fMaxStepGas;
+}
-void AliMUON::SetNsec(Int_t id, Int_t nsec)
+//____________________________________________________________________
+Float_t AliMUON::GetMaxStepAlu() const
{
- ((AliMUONchamber*) (*fChambers)[id])->SetNsec(nsec);
+/// Return step size in Alu
+
+ return fMaxStepAlu;
}
-
-
-//___________________________________________
-
-void AliMUON::StepManager()
-{
- printf("Dummy version of muon step -- it should never happen!!\n");
- const Float_t kRaddeg = 180/TMath::Pi();
- Int_t nsec, ipart;
- Float_t x[4], p[4];
- Float_t pt, th0, th1;
- char proc[5];
- if(fAccCut) {
- if((nsec=gMC->NSecondaries())>0) {
- gMC->ProdProcess(proc);
- if((gMC->TrackPid()==113 || gMC->TrackPid()==114) && !strcmp(proc,"DCAY")) {
- //
- // Check angular acceptance
- //* --- and have muons from resonance decays in the wanted window ---
- if(nsec != 2) {
- printf(" AliMUON::StepManager: Strange resonance Decay into %d particles\n",nsec);
- gMC->StopEvent();
- } else {
- gMC->GetSecondary(0,ipart,x,p);
- pt = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
- th0 = TMath::ATan2(pt,p[2])*kRaddeg;
- gMC->GetSecondary(1,ipart,x,p);
- pt = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
- th1 = TMath::ATan2(pt,p[2])*kRaddeg;
- if(!(fAccMin < th0 && th0 < fAccMax) ||
- !(fAccMin < th1 && th1 < fAccMax))
- gMC->StopEvent();
- }
- }
- }
- }
+
+//____________________________________________________________________
+Float_t AliMUON::GetMaxDestepGas() const
+{
+/// Return maximum step size in Gas
+
+ return fMaxDestepGas;
}
-void AliMUON::ReconstructClusters()
-{
-//
-// Initialize the necessary correspondance table
-//
- static const Int_t kMaxNpadx = 600;
- static const Int_t kMaxNpady = 600;
- Int_t elem[kMaxNpadx*2][kMaxNpady*2];
-//
-// Loop on chambers and on cathode planes
-//
- for (Int_t ich=0;ich<10;ich++)
- for (Int_t icat=0;icat<2;icat++) {
- //
- // Get ready the current chamber stuff
- //
- AliMUONchamber* iChamber= &(this->Chamber(ich));
- AliMUONsegmentation* segmentation =
- iChamber->GetSegmentationModel(icat+1);
- if (!segmentation)
- continue;
- TClonesArray *MUONdigits = this->DigitsAddress(ich);
- if (MUONdigits == 0)
- continue;
- cout << "Npx " << segmentation->Npx()
- << " Npy " << segmentation->Npy() << endl;
- //
- // Ready the digits
- //
- gAlice->ResetDigits();
- gAlice->TreeD()->GetEvent(icat+1); // spurious +1 ...
- Int_t ndigits = MUONdigits->GetEntriesFast();
- if (ndigits == 0)
- continue;
- printf("Found %d digits for cathode %d in chamber %d \n",
- ndigits,icat,ich+1);
- AliMUONdigit *mdig;
- AliMUONRecCluster *Cluster;
- //
- // Build the correspondance table
- //
- memset(elem,0,sizeof(Int_t)*kMaxNpadx*kMaxNpady*4);
- Int_t digit;
- for (digit=0; digit<ndigits; digit++)
- {
- mdig = (AliMUONdigit*)MUONdigits->UncheckedAt(digit);
- elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY] = digit+1;
- // because default is 0
- }
- //
- // Declare some useful variables
- //
- Int_t Xlist[10];
- Int_t Ylist[10];
- Int_t Nlist;
- Int_t nclust=0;
- //
- // loop over digits
- //
- for (digit=0;digit<ndigits;digit++) {
- mdig = (AliMUONdigit*)MUONdigits->UncheckedAt(digit);
- //
- // if digit still available, start clustering
- //
- if (elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY]) {
- Cluster = new AliMUONRecCluster(digit, ich, icat);
- elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY]=0;
- //
- // loop over the current list of digits
- // and look for neighbours
- //
- for(Int_t clusDigit=Cluster->FirstDigitIndex();
- clusDigit!=Cluster->InvalidDigitIndex();
- clusDigit=Cluster->NextDigitIndex()) {
- AliMUONdigit* pDigit=(AliMUONdigit*)MUONdigits
- ->UncheckedAt(clusDigit);
- segmentation->Neighbours(pDigit->fPadX,pDigit->fPadY,
- &Nlist, Xlist, Ylist);
- for (Int_t Ilist=0;Ilist<Nlist;Ilist++) {
- if (elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady
- +Ylist[Ilist]]) {
- //
- // Add the digit at the end and reset the table
- //
- Cluster->AddDigit(elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady+Ylist[Ilist]]-1);
- elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady
- +Ylist[Ilist]] =0;
- } // if elem
- } // for Ilist
- } // for pDigit
- //
- // Store the cluster (good time to do Cluster polishing)
- //
- segmentation->FitXY(Cluster,MUONdigits);
- nclust ++;
- AddRecCluster(ich,icat,Cluster);
- }
- }
- printf("===> %d Clusters\n",nclust);
- } // for icat
+
+//____________________________________________________________________
+Float_t AliMUON::GetMaxDestepAlu() const
+{
+/// Return maximum step size in Gas
+
+ return fMaxDestepAlu;
}
+//____________________________________________________________________
+ void AliMUON::SetAlign(Bool_t align)
+{
+/// Set option for alignement to geometry builder
-//______________________________________________________________________________
-void AliMUON::Streamer(TBuffer &R__b)
-{
- // Stream an object of class AliMUON.
- AliMUONchamber *iChamber;
- AliMUONsegmentation *segmentation;
- AliMUONresponse *response;
- TClonesArray *digitsaddress;
-
- if (R__b.IsReading()) {
- Version_t R__v = R__b.ReadVersion(); if (R__v) { }
- AliDetector::Streamer(R__b);
- R__b >> fNclusters;
- R__b >> fClusters; // diff
- R__b >> fDchambers;
- R__b.ReadArray(fNdch);
- //
- R__b >> fAccCut;
- R__b >> fAccMin;
- R__b >> fAccMax;
- //
- R__b >> fChambers;
-// Stream chamber related information
- for (Int_t i =0; i<10; i++) {
- iChamber=(AliMUONchamber*) (*fChambers)[i];
- iChamber->Streamer(R__b);
- if (iChamber->Nsec()==1) {
- segmentation=iChamber->GetSegmentationModel(1);
- segmentation->Streamer(R__b);
- } else {
- segmentation=iChamber->GetSegmentationModel(1);
- segmentation->Streamer(R__b);
- segmentation=iChamber->GetSegmentationModel(2);
- segmentation->Streamer(R__b);
- }
- response=iChamber->GetResponseModel();
- response->Streamer(R__b);
- digitsaddress=(TClonesArray*) (*fDchambers)[i];
- digitsaddress->Streamer(R__b);
- }
-
- } else {
- R__b.WriteVersion(AliMUON::IsA());
- AliDetector::Streamer(R__b);
- R__b << fNclusters;
- R__b << fClusters; // diff
- R__b << fDchambers;
- R__b.WriteArray(fNdch, 10);
- //
- R__b << fAccCut;
- R__b << fAccMin;
- R__b << fAccMax;
- //
- R__b << fChambers;
-// Stream chamber related information
- for (Int_t i =0; i<10; i++) {
- iChamber=(AliMUONchamber*) (*fChambers)[i];
- iChamber->Streamer(R__b);
- if (iChamber->Nsec()==1) {
- segmentation=iChamber->GetSegmentationModel(1);
- segmentation->Streamer(R__b);
- } else {
- segmentation=iChamber->GetSegmentationModel(1);
- segmentation->Streamer(R__b);
- segmentation=iChamber->GetSegmentationModel(2);
- segmentation->Streamer(R__b);
- }
- response=iChamber->GetResponseModel();
- response->Streamer(R__b);
-
- digitsaddress=(TClonesArray*) (*fDchambers)[i];
- digitsaddress->Streamer(R__b);
- }
- }
-}
-AliMUONcluster* AliMUON::FirstPad(AliMUONhit* hit)
-{
-//
- // Initialise the pad iterator
- // Return the address of the first padhit for hit
- TClonesArray *theClusters = Clusters();
- Int_t nclust = theClusters->GetEntriesFast();
- if (nclust && hit->fPHlast > 0) {
- sMaxIterPad=hit->fPHlast;
- sCurIterPad=hit->fPHfirst;
- return (AliMUONcluster*) fClusters->UncheckedAt(sCurIterPad-1);
- } else {
- return 0;
- }
-}
+ fGeometryBuilder->SetAlign(align);
+}
-AliMUONcluster* AliMUON::NextPad()
+//____________________________________________________________________
+ void AliMUON::SetAlign(const TString& fileName, Bool_t align)
{
- sCurIterPad++;
- if (sCurIterPad <= sMaxIterPad) {
- return (AliMUONcluster*) fClusters->UncheckedAt(sCurIterPad-1);
- } else {
- return 0;
- }
-}
-
-ClassImp(AliMUONcluster)
+/// Set option for alignement to geometry builder
-//___________________________________________
-AliMUONcluster::AliMUONcluster(Int_t *clhits)
-{
- fHitNumber=clhits[0];
- fCathode=clhits[1];
- fQ=clhits[2];
- fPadX=clhits[3];
- fPadY=clhits[4];
- fQpad=clhits[5];
- fRSec=clhits[6];
-}
-ClassImp(AliMUONdigit)
-//_____________________________________________________________________________
-AliMUONdigit::AliMUONdigit(Int_t *digits)
-{
- //
- // Creates a MUON digit object to be updated
- //
- fPadX = digits[0];
- fPadY = digits[1];
- fSignal = digits[2];
+ fGeometryBuilder->SetAlign(fileName, align);
+}
-}
-//_____________________________________________________________________________
-AliMUONdigit::AliMUONdigit(Int_t *tracks, Int_t *charges, Int_t *digits)
-{
- //
- // Creates a MUON digit object
- //
- fPadX = digits[0];
- fPadY = digits[1];
- fSignal = digits[2];
- for(Int_t i=0; i<10; i++) {
- fTcharges[i] = charges[i];
- fTracks[i] = tracks[i];
- }
+//____________________________________________________________________
+void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
+{
+/// Set the response for chamber id
+ ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
}
-ClassImp(AliMUONlist)
-
-//____________________________________________________________________________
- AliMUONlist::AliMUONlist(Int_t rpad, Int_t *digits):
- AliMUONdigit(digits)
+//____________________________________________________________________
+AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager) const
{
- //
- // Creates a MUON digit list object
- //
-
- fRpad = rpad;
- fTrackList = new TObjArray;
-
+/// FIXME: the selection of the class should be done through a factory
+/// mechanism. (see also Hits2SDigits()).
+
+ AliInfo(Form("Digitizer used : %s",fDigitizerType.Data()));
+
+ if ( fDigitizerType == "digitizer:default" )
+ {
+ return new AliMUONDigitizerv2(manager);
+ }
+ else if ( fDigitizerType == "digitizer:NewDigitizerNewTrigger" )
+ {
+ return new AliMUONDigitizerV3(manager,AliMUONDigitizerV3::kTriggerElectronics);
+ }
+ else if ( fDigitizerType == "digitizer:NewDigitizerOldTrigger" )
+ {
+ return new AliMUONDigitizerV3(manager,AliMUONDigitizerV3::kTriggerDecision, kFALSE, kFALSE);
+ }
+ else if ( fDigitizerType == "digitizer:NewDigitizerEffTrigger" )
+ {
+ return new AliMUONDigitizerV3(manager,AliMUONDigitizerV3::kTriggerDecision, kTRUE, kFALSE);
+ }
+ else if ( fDigitizerType == "digitizer:NewDigitizerWithNoiseOldTrigger" )
+ {
+ return new AliMUONDigitizerV3(manager,AliMUONDigitizerV3::kTriggerDecision, kFALSE, kTRUE);
+ }
+ else
+ {
+ AliFatal(Form("Unknown digitizer type : %s",fDigitizerType.Data()));
+ }
+ return 0x0;
}
-//_____________________________________________________________________________
+//_____________________________________________________________________
+TString
+AliMUON::SDigitizerType() const
+{
+/// Return digitizer type
-ClassImp(AliMUONhit)
-
-//___________________________________________
- AliMUONhit::AliMUONhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
- AliHit(shunt, track)
-{
- fChamber=vol[0];
- fParticle=(Int_t) hits[0];
- fX=hits[1];
- fY=hits[2];
- fZ=hits[3];
- fTheta=hits[4];
- fPhi=hits[5];
- fTlength=hits[6];
- fEloss=hits[7];
- fPHfirst=(Int_t) hits[8];
- fPHlast=(Int_t) hits[9];
+ return fSDigitizerType;
}
-ClassImp(AliMUONreccluster)
-
-ClassImp(AliMUONRecCluster)
//_____________________________________________________________________
-AliMUONRecCluster::AliMUONRecCluster()
+void AliMUON::SDigits2Digits()
{
- fDigits=0;
- fNdigit=-1;
-}
+/// Write TreeD here only
-AliMUONRecCluster::
-AliMUONRecCluster(Int_t FirstDigit,Int_t Ichamber, Int_t Icathod)
-{
- fX = 0.;
- fY = 0.;
- fDigits = new TArrayI(10);
- fNdigit=0;
- AddDigit(FirstDigit);
- fChamber=Ichamber;
- fCathod=Icathod;
+ char hname[30];
+ // sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
+ fLoader->TreeD()->Write(hname,TObject::kOverwrite);
+ fLoader->TreeD()->Reset();
}
-void AliMUONRecCluster::AddDigit(Int_t Digit)
+//_____________________________________________________________________
+void AliMUON::Hits2SDigits()
{
- if (fNdigit==fDigits->GetSize()) {
- //enlarge the list by hand!
- Int_t *array= new Int_t[fNdigit*2];
- for(Int_t i=0;i<fNdigit;i++)
- array[i] = fDigits->At(i);
- fDigits->Adopt(fNdigit*2,array);
+/// FIXME: the selection of the sdigitizer should be done through a
+/// factory mechanism.
+
+ AliInfo(Form("SDigitizer used : %s",fSDigitizerType.Data()));
+
+ if ( fSDigitizerType == "sdigitizer:default" )
+ {
+ // Adaption of AliMUONSDigitizerv1 to be excuted by the AliSimulation framework
+ AliRunLoader* runLoader = fLoader->GetRunLoader();
+ AliRunDigitizer * manager = new AliRunDigitizer(1,1);
+ manager->SetInputStream(0,runLoader->GetFileName(),AliConfig::GetDefaultEventFolderName());
+ AliMUONDigitizer * dMUON = new AliMUONSDigitizerv1(manager);
+ fLoader->LoadHits("READ");
+ for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) {
+ runLoader->GetEvent(iEvent);
+ dMUON->Exec("");
}
- fDigits->AddAt(Digit,fNdigit);
- fNdigit++;
+ fLoader->UnloadHits();
+ }
+ else if ( fSDigitizerType == "sdigitizer:AliMUONSDigitizerV2" )
+ {
+ TTask* sdigitizer = new AliMUONSDigitizerV2;
+ sdigitizer->ExecuteTask();
+ }
+ else
+ {
+ AliFatal(Form("Unknown sdigitizer classname : %s",fSDigitizerType.Data()));
+ }
}
-
-AliMUONRecCluster::~AliMUONRecCluster()
+//_____________________________________________________________________
+TString
+AliMUON::DigitizerType() const
{
- if (fDigits)
- delete fDigits;
-}
+/// Return digitizer type
-Int_t AliMUONRecCluster::FirstDigitIndex()
-{
- fCurrentDigit=0;
- return fDigits->At(fCurrentDigit);
+ return fDigitizerType;
}
-Int_t AliMUONRecCluster::NextDigitIndex()
+//_____________________________________________________________________
+void AliMUON::Digits2Raw()
{
- fCurrentDigit++;
- if (fCurrentDigit<fNdigit)
- return fDigits->At(fCurrentDigit);
- else
- return InvalidDigitIndex();
-}
+/// Convert digits of the current event to raw data
-Int_t AliMUONRecCluster::NDigits()
-{
- return fNdigit;
+ if (!fRawWriter)
+ {
+ fRawWriter = new AliMUONRawWriter(fMUONData);
+ if (fTriggerScalerEvent == kTRUE)
+ {
+ fRawWriter->SetScalersNumbers();
+ }
+ }
+
+ if (!fRawWriter->Digits2Raw())
+ {
+ AliError("pb writting raw data");
+ }
}
-void AliMUONRecCluster::Finish()
-{
- // In order to reconstruct coordinates, one has to
- // get back to the digits which is not trivial here,
- // because we don't know where digits are stored!
- // Center Of Gravity, or other method should be
- // a property of AliMUON class!
+//_______________________________________________________________________
+AliLoader* AliMUON::MakeLoader(const char* topfoldername)
+{
+/// Build standard getter (AliLoader type);
+/// if detector wants to use castomized getter, it must overload this method
+
+ AliDebug(1,Form("Creating standard getter for detector %s. Top folder is %s.",
+ GetName(),topfoldername));
+ fLoader = new AliLoader(GetName(),topfoldername);
+ fMUONData = new AliMUONData(fLoader,GetName(),GetName());
+ fMUONData->SetSplitLevel(fSplitLevel);
+ return fLoader;
}
+//_______________________________________________________________________
+AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
+{
+/// Return rawcluster (icluster) for chamber ichamber and cathode icathod
+/// Obsolete ??
+ TClonesArray *muonRawCluster = GetMUONData()->RawClusters(ichamber);
+ ResetRawClusters();
+ TTree *treeR = fLoader->TreeR();
+ Int_t nent=(Int_t)treeR->GetEntries();
+ treeR->GetEvent(nent-2+icathod-1);
+ //treeR->GetEvent(icathod);
+ //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
+ AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
+ //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
+
+ return mRaw;
+}
+//________________________________________________________________________
+void
+AliMUON::ResetGeometryBuilder()
+{
+/// Only to be used by "experts" wanting to change the geometry builders
+/// to be used.
+/// As the ctor of AliMUON now defines a default geometrybuilder, this
+/// ResetGeometryBuilder() must be called prior to call the
+/// AddGeometryBuilder()
-
-
-
-
-
-
+ delete fGeometryBuilder;
+ fGeometryBuilder = new AliMUONGeometryBuilder(this);
+ fGeometryBuilder
+ ->AddBuilder(new AliMUONCommonGeometryBuilder(this));
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff