Ignore:
Timestamp:
04/22/05 15:32:22 (20 years ago)
Author:
meyer
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/mmuon
Files:
4 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.cc

    r5332 r6973  
    3838//  Input Containers:
    3939//   [MGeomCam]
    40 //   [MCerPhotEvt]
     40//   [MSignalCam]
    4141//   [MMuonSearchPar]
    4242//
    … …  
    4848#include "MLog.h"
    4949#include "MLogManip.h"
    50 #include "MCerPhotEvt.h"
    51 #include "MCerPhotPix.h"
     50#include "MSignalCam.h"
     51#include "MSignalPix.h"
    5252#include "MMuonSearchPar.h"
    5353#include "MBinning.h"
    … …  
    8585    fHistWidth->UseCurrentStyle();
    8686
    87     fMargin = 60.;  // in mm
    88     fArcPhiThres  = 100.;
    89     fArcWidthThres  = 100.;
    90     fArcPhiBinNum = 20;
    91     fArcPhiHistStartVal = -180.; // deg.
    92     fArcPhiHistEndVal   = 180.;  // deg.
    93     fArcWidthBinNum = 28;
    94     fArcWidthHistStartVal = 0.3; // deg.
    95     fArcWidthHistEndVal   = 1.7; // deg.
    9687}
    9788
    … …  
    137128}
    138129
    139 
    140 
    141 

  • trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.h

    r5331 r6973  
    1010#endif
    1111
    12 class MCerPhotEvt;
     12class MSignalCam;
    1313class MMuonSearchPar;
    1414
    … …  
    2323  Float_t fMuonSize;      // A SIZE of muon which is defined as a SIZE around the estimated circle
    2424  Float_t fEstImpact;     // An estimated impact parameter from the photon distribution along the arc image
    25   Float_t fMargin;        // margin to evaluate muons [mm]. The defaut value is 60 mm, corresponding to 0.2 deg. This value can be changed by using the function of SetMargin
    2625  Bool_t  fUseUnmap;      // This is a flag to know the Unmapped pixels are used. Refer to the class of MImgCleanStd
    2726  Float_t fPeakPhi;       // The angle which indicates the peak position in the estimated circle
    28   Float_t fArcPhiThres;   // The threshold value to define arc phi
    29   Float_t fArcWidthThres; // The threshold value to define arc width
    3027
    3128public:
    … …  
    3330  ~MMuonCalibPar();
    3431 
    35   Int_t   fArcPhiBinNum;         // The bin number for the histogram of arc phi. You may change this value. However, if you change this, YOU ALSO HAVE TO CHANGE THE THRESHOLD VALUE TO GET ARC LENGTH.
    36   Int_t   fArcWidthBinNum;       // The bin number for the histogram of arc wid
    37   Float_t fArcPhiHistStartVal;   // The starting value for the histogram of arc phi
    38   Float_t fArcPhiHistEndVal;     // The end value for the histogram of arc phi
    39   Float_t fArcWidthHistStartVal; // The starting value for the histogram of arc width
    40   Float_t fArcWidthHistEndVal;   // The end value for the histogram of arc width
    41 
    4232  TH1F *fHistPhi;   // Histogram of photon distribution along the arc.
    4333  TH1F *fHistWidth; // Histogram of radial photon distribution of the arc.
    … …  
    5040  Float_t GetChiArcPhi()      const { return fChiArcPhi; }
    5141  Float_t GetChiArcWidth()    const { return fChiArcWidth; }
    52   Float_t GetMargin()         const { return fMargin; }
    5342  Float_t GetMuonSize()       const { return fMuonSize; }
    5443  Float_t GetEstImpact()      const { return fEstImpact; }
    5544  Bool_t  IsUseUnmap()        const { return fUseUnmap; }
    5645  Float_t GetPeakPhi()        const { return fPeakPhi; }
    57   Float_t GetArcPhiThres()    const { return fArcPhiThres; }
    58   Float_t GetArcWidthThres()  const { return fArcWidthThres; }
    59   Float_t GetArcPhiBinNum()   const { return fArcPhiBinNum; }
    60   Float_t GetArcWidthBinNum() const { return fArcWidthBinNum; }
    6146  TH1F    *GetHistPhi()       { return fHistPhi; }
    6247  TH1F    *GetHistWidth()     { return fHistWidth; }
    … …  
    6752  void    SetChiArcPhi(Float_t chi)       { fChiArcPhi = chi; }
    6853  void    SetChiArcWidth(Float_t chi)     { fChiArcWidth = chi; }
    69   void    SetMargin(Float_t margin)       { fMargin = margin; }
    7054  void    SetMuonSize(Float_t size)       { fMuonSize = size; }
    7155  void    SetEstImpact(Float_t impact)    { fEstImpact = impact; }
    7256  void    SetUseUnmap()                   { fUseUnmap = kTRUE; }
    7357  void    SetPeakPhi(Float_t phi)         { fPeakPhi = phi; }
    74   void    SetArcPhiThres(Float_t thres)   { fArcPhiThres = thres; }
    75   void    SetArcWidthThres(Float_t thres) { fArcWidthThres = thres; }
    76   void    SetArcPhiBinNum(Int_t num)      { fArcPhiBinNum = num; }
    77   void    SetArcWidthBinNum(Int_t num)    { fArcWidthBinNum = num; }
    7858 
    7959  void    Print(Option_t *opt=NULL) const;

  • trunk/MagicSoft/Mars/mmuon/MMuonCalibParCalc.cc

    r5333 r6973  
    9999//  Input Containers:
    100100//   [MGeomCam]
    101 //   [MCerPhotEvt]
     101//   [MSignalCam]
    102102//   [MMuonSearchPar]
    103103//
    … …  
    120120#include "MGeomPix.h"
    121121#include "MSrcPosCam.h"
    122 #include "MCerPhotEvt.h"
     122#include "MSignalCam.h"
    123123#include "MMuonSearchPar.h"
    124124#include "MMuonCalibPar.h"
     125#include "MMuonSetup.h"
    125126#include "MLog.h"
    126127#include "MLogManip.h"
    … …  
    139140//
    140141MMuonCalibParCalc::MMuonCalibParCalc(const char *name, const char *title)
    141   : fNameCerPhot("MCerPhotEvt")
    142142{
    143143    fName  = name  ? name  : gsDefName.Data();
    144144    fTitle = title ? title : gsDefTitle.Data();
    145145
    146     fPreCuts[0]     = 180.;
    147     fPreCuts[1]     = 400.;
    148     fPreCuts[2]     = 50.;
    149     fPreCuts[3]     = 2000.;
    150     fPreCuts[4]     = 150.;
    151 
    152     fMargin = 60.;
    153     fArcPhiThres = 100.;
    154     fArcWidthThres = 100.;
    155 
    156146    fEnableImpactCalc = kFALSE; // By default the calculation of impact parameter is skipped.
    157     fDisablePreCuts =   kFALSE; // By default the pre cuts will be applied.
    158147}
    159148
    … …  
    162151Int_t MMuonCalibParCalc::PreProcess(MParList *pList)
    163152{
    164   fCerPhotEvt = (MCerPhotEvt*)pList->FindObject(AddSerialNumber(fNameCerPhot), "MCerPhotEvt");
    165   if (!fCerPhotEvt)
    166     {
    167       *fLog << dbginf << "MCerPhotEvt not found... aborting." << endl;
     153  fSignalCam = (MSignalCam*)pList->FindObject("MSignalCam");
     154  if (!fSignalCam)
     155    {
     156      *fLog << dbginf << "MSignalCam not found... aborting." << endl;
    168157      return kFALSE;
    169158    }
    … …  
    178167  fMuonCalibPar = (MMuonCalibPar*)pList->FindCreateObj("MMuonCalibPar", "MMuonCalibPar");
    179168  if (!fMuonCalibPar)
    180     {
    181       *fLog << dbginf << "MMuonCalibPar missing in Parameter List... aborting." << endl;
    182169      return kFALSE;
    183     }
    184170 
    185171  fMuonSearchPar = (MMuonSearchPar*)pList->FindCreateObj("MMuonSearchPar", "MMuonSearchPar");
    186172  if (!fMuonSearchPar)
    187     {
    188       *fLog << dbginf << "MMuonSearchPar missing in Parameter List... aborting." << endl;
    189173      return kFALSE;
    190     }
     174
     175  fMuonSetup = (MMuonSetup*)pList->FindCreateObj("MMuonSetup", "MMuonSetup");
     176  if (!fMuonSetup)
     177      return kFALSE;
    191178 
    192179  return kTRUE;
    … …  
    203190  Float_t MuonSize = 0.;
    204191
    205   Int_t binnumphi = fMuonCalibPar->fArcPhiBinNum;
    206   Int_t binnumwid = fMuonCalibPar->fArcWidthBinNum;
     192  Int_t binnumphi = fMuonSetup->fArcPhiBinNum;
     193  Int_t binnumwid = fMuonSetup->fArcWidthBinNum;
    207194
    208195  // preparation for a histgram
    209196  MBinning binsphi;
    210197  binsphi.SetEdges(binnumphi,
    211                    fMuonCalibPar->fArcPhiHistStartVal,
    212                    fMuonCalibPar->fArcPhiHistEndVal);
     198                   fMuonSetup->fArcPhiHistStartVal,
     199                   fMuonSetup->fArcPhiHistEndVal);
    213200  binsphi.Apply(*(fMuonCalibPar->fHistPhi));
    214201
    215202  MBinning binswid;
    216203  binswid.SetEdges(binnumwid,
    217                    fMuonCalibPar->fArcWidthHistStartVal,
    218                    fMuonCalibPar->fArcWidthHistEndVal);
     204                   fMuonSetup->fArcWidthHistStartVal,
     205                   fMuonSetup->fArcWidthHistEndVal);
    219206  binswid.Apply(*(fMuonCalibPar->fHistWidth));
    220207
    221   const Int_t entries = (*fCerPhotEvt).GetNumPixels();
     208  const Int_t entries = (*fSignalCam).GetNumPixels();
    222209
    223210  // the position of the center of a muon ring
    … …  
    227214  for (Int_t i=0; i<entries; i++ )
    228215    {
    229       MCerPhotPix &pix = (*fCerPhotEvt)[i];
    230      
    231       const MGeomPix &gpix = (*fGeomCam)[pix.GetPixId()];
     216      MSignalPix &pix = (*fSignalCam)[i];
     217     
     218      const MGeomPix &gpix = (*fGeomCam)[i/*pix.GetPixId()*/];
    232219     
    233220      const Float_t dx = gpix.GetX() - cenx;
    … …  
    241228     
    242229      // if the signal is not near the estimated circle, it is ignored.
    243       if(dist < (*fMuonSearchPar).GetRadius() + fMuonCalibPar->GetMargin()
    244          && dist > (*fMuonSearchPar).GetRadius() - fMuonCalibPar->GetMargin())
     230      if(dist < (*fMuonSearchPar).GetRadius() + fMuonSetup->GetMargin()
     231         && dist > (*fMuonSearchPar).GetRadius() - fMuonSetup->GetMargin())
    245232        {
    246233          // check whether ummapped pixel is used or not.
    … …  
    257244      // use only the inner pixles. This is geometry dependent. This has to
    258245      // be fixed!
    259       if(pix.GetPixId()>397)
     246      if(i>397)
    260247        continue; 
    261248     
    … …  
    298285void MMuonCalibParCalc::CalcPhi()
    299286{
    300   Float_t thres = fMuonCalibPar->GetArcPhiThres();
    301   Float_t startval = fMuonCalibPar->fArcPhiHistStartVal;
    302   Float_t endval = fMuonCalibPar->fArcPhiHistEndVal;
    303   Int_t   binnum = fMuonCalibPar->fArcPhiBinNum;
     287  Float_t thres = fMuonSetup->GetArcPhiThres();
     288  Float_t startval = fMuonSetup->fArcPhiHistStartVal;
     289  Float_t endval = fMuonSetup->fArcPhiHistEndVal;
     290  Int_t   binnum = fMuonSetup->fArcPhiBinNum;
    304291
    305292  Float_t convbin2val = (endval-startval)/(Float_t)binnum;
    … …  
    458445Float_t MMuonCalibParCalc::CalcWidth()
    459446{
    460   Float_t startval = fMuonCalibPar->fArcWidthHistStartVal;
    461   Float_t endval = fMuonCalibPar->fArcWidthHistEndVal;
    462   Int_t   binnum = fMuonCalibPar->fArcWidthBinNum;
    463   Float_t thres = fMuonCalibPar->GetArcWidthThres();
     447  Float_t startval = fMuonSetup->fArcWidthHistStartVal;
     448  Float_t endval = fMuonSetup->fArcWidthHistEndVal;
     449  Int_t   binnum = fMuonSetup->fArcWidthBinNum;
     450  Float_t thres = fMuonSetup->GetArcWidthThres();
    464451
    465452  Float_t convbin2val = (endval - startval)
    … …  
    500487    TF1 f1("f1","gaus",startfitval,endfitval);
    501488
     489    // options : N  do not store the function, do not draw
     490    //           I  use integral of function in bin rather than value at bin center
     491    //           R  use the range specified in the function range
     492    //           Q  quiet mode
    502493    fMuonCalibPar->fHistWidth->Fit("f1","QR","",startfitval,endfitval);
    503494   
    … …  
    515506//  Calculation of muon parameters
    516507//
    517 Int_t MMuonCalibParCalc::Calc(const Float_t *cuts)
    518 {
    519   // sanity check
    520   if((*fCerPhotEvt).GetNumPixels() < 3)
    521     return kCONTINUE;
    522 
    523   // If an event does not seem to be like muon, the calculation will be skipped.
    524   if((*fMuonSearchPar).IsNoMuon())
    525     return kCONTINUE;
    526 
    527   // Pre Cuts 1
    528   if(!fDisablePreCuts)
    529     {
    530       if((*fMuonSearchPar).GetRadius() < cuts[0] || (*fMuonSearchPar).GetRadius() > cuts[1])
    531         {
    532           (*fMuonSearchPar).SetNoMuon();
    533           return kCONTINUE;
    534         }
    535       if((*fMuonSearchPar).GetDeviation() > cuts[2])
    536         {
    537           (*fMuonSearchPar).SetNoMuon();
    538           return kCONTINUE;
    539         }
    540     }
    541 
     508Int_t MMuonCalibParCalc::Calc()
     509{
    542510  // initialization
    543511  (*fMuonCalibPar).Reset();
    … …  
    549517  CalcPhi();
    550518
    551   // Pre Cuts 2
    552   if(!fDisablePreCuts)
    553     {
    554       if(fMuonCalibPar->GetMuonSize() < cuts[3]
    555          || fMuonCalibPar->GetArcPhi() < cuts[4])
    556         {
    557           (*fMuonSearchPar).SetNoMuon();
    558           return kCONTINUE;
    559         }
    560     }
    561 
    562519  // Calculation of Arc Width etc...
    563   fMuonCalibPar->SetArcWidth(CalcWidth());
     520  fMuonCalibPar->SetArcWidth(CalcWidth());
     521
     522  if(fMuonCalibPar->GetArcPhi()>160 && fMuonSearchPar->GetRadius()>170 &&
     523     fMuonSearchPar->GetRadius()<400 && fMuonSearchPar->GetDeviation()<50)
     524      fMuonCalibPar->SetReadyToSave();
    564525 
    565526  return kTRUE;
    566527}
    567528
    568 
    569529// -------------------------------------------------------------------------
    570530//
    571531Int_t MMuonCalibParCalc::Process()
    572532{
    573   fMuonCalibPar->SetMargin(fMargin);
    574   fMuonCalibPar->SetArcPhiThres(fArcPhiThres);
    575   fMuonCalibPar->SetArcWidthThres(fArcWidthThres);
    576 
    577   if(!Calc(fPreCuts))
    578     return kCONTINUE;
     533
     534  Calc();
    579535
    580536  return kTRUE;
    581537}
    582 
    583 void MMuonCalibParCalc::SetPreCuts
    584 (Float_t radcutlow, Float_t radcuthigh, Float_t devcuthigh,
    585  Float_t musizecutlow, Float_t arcphicutlow)
    586 {
    587   fPreCuts[0] = radcutlow;
    588   fPreCuts[1] = radcuthigh;
    589   fPreCuts[2] = devcuthigh;
    590   fPreCuts[3] = musizecutlow;
    591   fPreCuts[4] = arcphicutlow;
    592 }
    593 

  • trunk/MagicSoft/Mars/mmuon/MMuonCalibParCalc.h

    r5332 r6973  
    1010class MSrcPosCam;
    1111class MGeomCam;
    12 class MCerPhotEvt;
     12class MSignalCam;
     13class MMuonSetup;
    1314
    1415class MMuonCalibParCalc : public MTask
    … …  
    1617private:
    1718    MGeomCam       *fGeomCam;
    18     MCerPhotEvt    *fCerPhotEvt;
     19    MSignalCam     *fSignalCam;
    1920    MMuonCalibPar  *fMuonCalibPar; 
    2021    MMuonSearchPar *fMuonSearchPar;
     22    MMuonSetup     *fMuonSetup;
    2123
    22     Float_t fMargin;           // margin to evaluate muons [mm]. The defaut value is 60 mm, corresponding to 0.2 deg. This value can be changed by using the function of SetMargin
    23     Float_t fArcPhiThres;     // The threshold value to define arc phi
    24     Float_t fArcWidthThres;   // The threshold value to define arc width
    2524    Bool_t fEnableImpactCalc; // If true, the impact calculation will be done, which consumes a lot of time.
    26     Bool_t fDisablePreCuts;   // If true, the pre cuts to select muons for the calibration will be disabled.
    27 
    28     Float_t fPreCuts[5];  // The values for pre cuts.
    2925
    3026    Int_t PreProcess(MParList *plist);
    3127    Int_t Process();
    3228
    33     TString fNameCerPhot;
    34 
    3529public:
    3630    MMuonCalibParCalc(const char *name=NULL, const char *title=NULL);
    3731
    38     void SetMargin(Float_t margin)       { fMargin = margin; }
    39     void SetArcPhiThres(Float_t thres)   { fArcPhiThres = thres; }
    40     void SetArcWidthThres(Float_t thres) { fArcWidthThres = thres; }
    4132    void EnableImpactCalc()              { fEnableImpactCalc = kTRUE; }
    42     void DisablePreCuts()                { fDisablePreCuts = kTRUE; }
    43     void SetPreCuts(Float_t radcutlow, Float_t radcuthigh, Float_t devcuthigh,
    44                     Float_t musizecutlow, Float_t arcphicutlow);
    45 
    46     void SetNameCerPhotEvt(const char *name) { fNameCerPhot = name; }
    4733
    4834    void FillHist();
    … …  
    5036    void CalcImpact(Int_t effbinnum, Float_t startfitval, Float_t endfitval);
    5137    Float_t CalcWidth();
    52     Int_t   Calc(const Float_t *cuts);
     38    Int_t   Calc();
    5339
    5440    ClassDef(MMuonCalibParCalc, 0) // task to calculate muon parameters
    … …  
    5642
    5743#endif
    58 

  • trunk/MagicSoft/Mars/mmuon/MMuonSearchPar.cc

    r5331 r6973  
    7171//   [MGeomCam]
    7272//   [MHillas]
    73 //   [MCerPhotEvt]
     73//   [MSignalCam]
    7474//
    7575/////////////////////////////////////////////////////////////////////////////
    … …  
    8383#include "MGeomCam.h"
    8484#include "MGeomPix.h"
    85 #include "MCerPhotEvt.h"
    86 #include "MCerPhotPix.h"
     85#include "MSignalPix.h"
     86#include "MSignalCam.h"
    8787
    8888using namespace std;
    … …  
    108108  fCenterX = 0.;
    109109  fCenterY = 0.;
    110   fNoMuon = kFALSE;
    111110}
    112111
    … …  
    138137//  and its RMS for the input position.
    139138//
    140 Bool_t MMuonSearchPar::CalcRadius(const MGeomCam &geom, const MCerPhotEvt &evt,
     139Bool_t MMuonSearchPar::CalcRadius(const MGeomCam &geom, const MSignalCam &evt,
    141140      Float_t x, Float_t y, Float_t &r, Float_t &sigma)
    142141{
    … …  
    146145
    147146  for (Int_t i=0; i<entries; i++ ){
    148     const MCerPhotPix &pix = evt[i];
     147    const MSignalPix &pix = evt[i];
    149148
    150149    if (!pix.IsPixelUsed())
    151150      continue;
    152151
    153     const MGeomPix &gpix = geom[pix.GetPixId()];
     152    const MGeomPix &gpix = geom[i/*pix.GetPixId()*/];
    154153
    155154    tmp=TMath::Sqrt((gpix.GetX()-x)*(gpix.GetX()-x)
    … …  
    180179//
    181180void MMuonSearchPar::CalcMinimumDeviation
    182 ( const MGeomCam &geom, const MCerPhotEvt &evt, Float_t x, Float_t y,
     181( const MGeomCam &geom, const MSignalCam &evt, Float_t x, Float_t y,
    183182 Float_t xcog, Float_t ycog, Float_t sigma, Float_t &opt_rad,
    184183 Float_t &new_sigma, Float_t &newx, Float_t &newy )
    … …  
    198197          newx=x;
    199198          newy=y;
    200           fNoMuon = kTRUE;
    201199          break;
    202200      }
    … …  
    253251//
    254252void MMuonSearchPar::Calc
    255 (const MGeomCam &geom, const MCerPhotEvt &evt, const MHillas &hillas)
     253(const MGeomCam &geom, const MSignalCam &evt, const MHillas &hillas)
    256254{
    257255  Reset();
    … …  
    283281  fCenterY = newy;
    284282 
    285   SetReadyToSave();
     283  //SetReadyToSave();
    286284}
    287285

  • trunk/MagicSoft/Mars/mmuon/MMuonSearchPar.h

    r5331 r6973  
    88class MHillas;
    99class MGeomCam;
    10 class MCerPhotEvt;
     10class MSignalCam;
    1111
    1212class MMuonSearchPar : public MParContainer
    … …  
    1717    Float_t fCenterX;   // An estimated center position in X of the muon ring [mm]
    1818    Float_t fCenterY;   // An estimated center position in Y of the muon ring [mm]
    19     Bool_t  fNoMuon;    // if the radius is estimated above 600 mm (2 deg.), assumed it's not muon. Later on, at the stage of MMuonCalibParCalc, this flag will be changed if the task judge the event as no muon.
    2019
    2120public:
    … …  
    2827    Float_t GetCenterX()   const { return fCenterX; }
    2928    Float_t GetCenterY()   const { return fCenterY; }
    30     Bool_t  IsNoMuon()     const { return fNoMuon; }
    31     void    SetNoMuon()          { fNoMuon = kTRUE; }
    3229
    3330    void   CalcTempCenter(const MHillas &hillas, Float_t &xtmp1,
    3431                          Float_t &ytmp1, Float_t &xtmp2, Float_t &ytmp2);
    35     Bool_t CalcRadius(const MGeomCam &geom, const MCerPhotEvt &evt, Float_t x,
     32    Bool_t CalcRadius(const MGeomCam &geom, const MSignalCam &evt, Float_t x,
    3633                      Float_t y, Float_t &r, Float_t &sigma);
    37     void   CalcMinimumDeviation(const MGeomCam &geom, const MCerPhotEvt &evt,
     34    void   CalcMinimumDeviation(const MGeomCam &geom, const MSignalCam &evt,
    3835                             Float_t x, Float_t y, Float_t xcog,
    3936                             Float_t ycog, Float_t sigma, Float_t &opt_rad,
    4037                             Float_t &new_sigma, Float_t &newx, Float_t &newy);
    41     void   Calc(const MGeomCam &geom, const MCerPhotEvt &evt,
     38    void   Calc(const MGeomCam &geom, const MSignalCam &evt,
    4239                const MHillas &hillas);
    4340

  • trunk/MagicSoft/Mars/mmuon/MMuonSearchParCalc.cc

    r5378 r6973  
    4343//   [MGeomCam]
    4444//   [MHillas]
    45 //   [MCerPhotEvt]
     45//   [MSignalCam]
    4646//
    4747//  Output Containers:
    … …  
    5555#include "MParList.h"
    5656#include "MGeomCam.h"
    57 #include "MCerPhotEvt.h"
     57#include "MSignalCam.h"
    5858#include "MMuonSearchPar.h"
    5959#include "MLog.h"
    … …  
    7373MMuonSearchParCalc::MMuonSearchParCalc
    7474(const char *mupar, const char *name, const char *title)
    75   : fHillas(NULL), fMuonPar(NULL), fCerPhotName("MCerPhotEvt")
     75  : fHillas(NULL), fMuonPar(NULL)
    7676{
    7777    fName  = name  ? name  : gsDefName.Data();
    … …  
    9393    }
    9494
    95     fCerPhotEvt = (MCerPhotEvt*)pList->FindObject(AddSerialNumber(fCerPhotName), "MCerPhotEvt");
    96     if (!fCerPhotEvt)
     95    fSignalCam = (MSignalCam*)pList->FindObject("MSignalCam");
     96    if (!fSignalCam)
    9797    {
    98         *fLog << err << fCerPhotName << " [MCerPhotEvt] not found... aborting." << endl;
     98        *fLog << err << "MSignalCam not found... aborting." << endl;
    9999        return kFALSE;
    100100    }
    … …  
    119119{
    120120
    121   fMuonPar->Calc(*fGeomCam, *fCerPhotEvt, *fHillas);
     121  fMuonPar->Calc(*fGeomCam, *fSignalCam, *fHillas);
    122122
    123123  return kTRUE;

  • trunk/MagicSoft/Mars/mmuon/MMuonSearchParCalc.h

    r5210 r6973  
    99class MMuonSearchPar;
    1010class MGeomCam;
    11 class MCerPhotEvt;
     11class MSignalCam;
    1212
    1313class MMuonSearchParCalc : public MTask
    … …  
    1515private:
    1616    MGeomCam    *fGeomCam;
    17     MCerPhotEvt *fCerPhotEvt;
     17    MSignalCam  *fSignalCam;
    1818    MHillas     *fHillas;      //! Pointer to the source independent hillas parameters
    1919    MMuonSearchPar *fMuonPar;  //! Pointer to the output container for the new image parameters
    … …  
    2121    TString fMuparName;
    2222    TString fHillasInput;
    23     TString fCerPhotName;
    2423
    2524    Int_t PreProcess(MParList *plist);
    … …  
    3231    void SetInput(TString hilname) { fHillasInput = hilname; }
    3332
    34     void SetNameCerPhotEvt(const char *name) { fCerPhotName = name; }
    35 
    3633    ClassDef(MMuonSearchParCalc, 0) // task to calculate muon parameters
    3734};

  • trunk/MagicSoft/Mars/mmuon/Makefile

    r5332 r6973  
    2828           MMuonSearchParCalc.cc \
    2929           MMuonCalibPar.cc \
    30            MMuonCalibParCalc.cc
     30           MMuonCalibParCalc.cc \
     31           MHMuonPar.cc \
     32           MMuonSetup.cc
    3133
    3234############################################################

  • trunk/MagicSoft/Mars/mmuon/MuonLinkDef.h

    r5332 r6973  
    99#pragma link C++ class MMuonCalibPar+;
    1010#pragma link C++ class MMuonCalibParCalc+;
     11#pragma link C++ class MHMuonPar+;
     12#pragma link C++ class MMuonSetup+;
    1113
    1214#endif
Note: See TracChangeset for help on using the changeset viewer.