X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUON.cxx;h=a667636f584aadad5a1f9b1dc2853790e720c068;hb=84ceeb061c491574f58f4af93d166ef9768ad95e;hp=9606ca821d26318229e5305c58ca9904233b280c;hpb=cfce887023b4d349cb7b743880a8f9086a600d9d;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUON.cxx b/MUON/AliMUON.cxx index 9606ca821d2..22b1cfb6d36 100644 --- a/MUON/AliMUON.cxx +++ b/MUON/AliMUON.cxx @@ -1,820 +1,616 @@ -//////////////////////////////////////////////// -// Manager and hits classes for set:MUON // -//////////////////////////////////////////////// - -#include +/************************************************************************** + * 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 +#include +#include +#include +#include +#include +#include #include -#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include -#include +#include -#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 -/* - -*/ -//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; circAddAt(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; circAddAt(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; digitUncheckedAt(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;digitUncheckedAt(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;IlistAddDigit(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;iAt(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 (fCurrentDigitAt(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)); +}