MUON/AliMUONClusterInput.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.4  2000/07/03 11:54:57  morsch
  19 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
  20 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
  21
  22 Revision 1.3  2000/06/28 15:16:35  morsch
  23 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
  24 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
  25 framework. The changes should have no side effects (mostly dummy arguments).
  26 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
  27 of chambers with overlapping modules (MakePadHits, Disintegration).
  28
  29 Revision 1.2  2000/06/28 12:19:18  morsch
  30 More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
  31 cluster and hit reconstruction algorithms in AliMUONClusterFinderVS.
  32 AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
  33 It requires two cathode planes. Small modifications in the code will make it usable for
  34 one cathode plane and, hence, more general (for test beam data).
  35 AliMUONClusterFinder is now obsolete.
  36
  37 Revision 1.1  2000/06/28 08:06:10  morsch
  38 Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
  39 algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
  40 It also naturally takes care of the TMinuit instance.
  41
  42 */
  43 #include "AliRun.h"
  44 #include "AliMUON.h"
  45 #include "AliMUONChamber.h"
  46 #include "AliMUONClusterInput.h"
  47 #include "AliSegmentation.h"
  48 #include "AliMUONResponse.h"
  49 #include "AliMUONRawCluster.h"
  50 #include "AliMUONDigit.h"
  51
  52 #include <TClonesArray.h>
  53 #include <TMinuit.h>
  54
  55 ClassImp(AliMUONClusterInput)
  56
  57 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
  58 TMinuit* AliMUONClusterInput::fgMinuit = 0;
  59
  60 AliMUONClusterInput* AliMUONClusterInput::Instance()
  61 {
  62 // return pointer to the singleton instance
  63     if (fgClusterInput == 0) {
  64         fgClusterInput = new AliMUONClusterInput();
  65         fgMinuit = new TMinuit(5);
  66     }
  67
  68     return fgClusterInput;
  69 }
  70
  71 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
  72 {
  73 // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
  74     fChamber=chamber;
  75     fDigits[0]=dig1;
  76     fDigits[1]=dig2;
  77     fNDigits[0]=dig1->GetEntriesFast();
  78     fNDigits[1]=dig2->GetEntriesFast();
  79
  80     AliMUON *pMUON;
  81     AliMUONChamber* iChamber;
  82
  83     pMUON = (AliMUON*) gAlice->GetModule("MUON");
  84     iChamber =  &(pMUON->Chamber(chamber));
  85
  86     fSegmentation[0]=iChamber->SegmentationModel(1);
  87     fSegmentation[1]=iChamber->SegmentationModel(2);
  88     fResponse=iChamber->ResponseModel();
  89     fNseg = 2;
  90 }
  91
  92 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
  93 {
  94 // Set pointer to digits with corresponding segmentations and responses (one cathode plane)
  95     fDigits[0]=dig;
  96     AliMUON *pMUON;
  97     AliMUONChamber* iChamber;
  98
  99     pMUON = (AliMUON*) gAlice->GetModule("MUON");
 100     iChamber =  &(pMUON->Chamber(chamber));
 101
 102     fSegmentation[0]=iChamber->SegmentationModel(1);
 103     fResponse=iChamber->ResponseModel();
 104     fNseg=1;
 105 }
 106
 107 void  AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
 108 {
 109 // Set the current cluster
 110     printf("\n %p \n", cluster);
 111     fCluster=cluster;
 112     Float_t qtot;
 113     Int_t   i, cath, ix, iy;
 114     AliMUONDigit* digit;
 115     fNmul[0]=cluster->fMultiplicity[0];
 116     fNmul[1]=cluster->fMultiplicity[1];
 117     printf("\n %p %p ", fDigits[0], fDigits[1]);
 118
 119     for (cath=0; cath<2; cath++) {
 120         qtot=0;
 121         for (i=0; i<fNmul[cath]; i++) {
 122             // pointer to digit
 123             digit =(AliMUONDigit*)
 124                 (fDigits[cath]->UncheckedAt(cluster->fIndexMap[i][cath]));
 125             // pad coordinates
 126             ix = digit->fPadX;
 127             iy = digit->fPadY;
 128             // pad charge
 129             fCharge[i][cath] = digit->fSignal;
 130             // pad centre coordinates
 131 //          fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
 132             // globals kUsed in fitting functions
 133             fix[i][cath]=ix;
 134             fiy[i][cath]=iy;
 135             // total charge per cluster
 136             qtot+=fCharge[i][cath];
 137         } // loop over cluster digits
 138         fQtot[cath]=qtot;
 139         fChargeTot[cath]=Int_t(qtot);
 140     }  // loop over cathodes
 141 }
 142
 143
 144
 145 Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
 146 {
 147 // par[0]    x-position of cluster
 148 // par[1]    y-position of cluster
 149
 150    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
 151 //  First Cluster
 152    fSegmentation[0]->SetHit(par[0],par[1],0);
 153    Float_t q1=fResponse->IntXY(fSegmentation[0]);
 154
 155    Float_t value = fQtot[0]*q1;
 156    return value;
 157 }
 158
 159 Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
 160 {
 161 // par[0]    x-position of cluster
 162 // par[1]    y-position of cluster
 163
 164    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 165 //  First Cluster
 166    fSegmentation[cath]->SetHit(par[0],par[1],0);
 167    Float_t q1=fResponse->IntXY(fSegmentation[cath]);
 168
 169    Float_t value = fQtot[cath]*q1;
 170    return value;
 171 }
 172
 173
 174 Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
 175 {
 176 // par[0]    x-position of first  cluster
 177 // par[1]    y-position of first  cluster
 178 // par[2]    x-position of second cluster
 179 // par[3]    y-position of second cluster
 180 // par[4]    charge fraction of first  cluster
 181 // 1-par[4]  charge fraction of second cluster
 182
 183    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
 184 //  First Cluster
 185    fSegmentation[0]->SetHit(par[0],par[1],0);
 186    Float_t q1=fResponse->IntXY(fSegmentation[0]);
 187
 188 //  Second Cluster
 189    fSegmentation[0]->SetHit(par[2],par[3],0);
 190    Float_t q2=fResponse->IntXY(fSegmentation[0]);
 191
 192    Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 193    return value;
 194 }
 195
 196 Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
 197 {
 198 // par[0]    x-position of first  cluster
 199 // par[1]    y-position of first  cluster
 200 // par[2]    x-position of second cluster
 201 // par[3]    y-position of second cluster
 202 // par[4]    charge fraction of first  cluster
 203 // 1-par[4]  charge fraction of second cluster
 204
 205    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 206 //  First Cluster
 207    fSegmentation[cath]->SetHit(par[0],par[1],0);
 208    Float_t q1=fResponse->IntXY(fSegmentation[cath]);
 209
 210 //  Second Cluster
 211    fSegmentation[cath]->SetHit(par[2],par[3],0);
 212    Float_t q2=fResponse->IntXY(fSegmentation[cath]);
 213    Float_t value;
 214    if (cath==0) {
 215        value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
 216    } else {
 217        value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
 218    }
 219    return value;
 220 }
 221
 222
 223