Index: trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.cc =================================================================== --- trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.cc (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.cc (revision 5173) @@ -0,0 +1,523 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Keiichi Mase 09/2004 +! Markus Meyer 09/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MMuonCalibPar +// +// Storage Container for muon +// +// This class holds some information for a calibraion using muons. Muons +// are identified by using the class of the MMuonSearchParCalc. You can fill +// these information by using the MMuonCalibParCalc. See also these class +// manuals. +// +// +// Input Containers: +// [MGeomCam] +// [MCerPhotEvt] +// [MMuonSearchPar] +// +///////////////////////////////////////////////////////////////////////////// +#include "MMuonCalibPar.h" + +#include + +#include +#include +#include + +#include "MLog.h" +#include "MLogManip.h" +#include "MGeomCam.h" +#include "MGeomPix.h" +#include "MCerPhotEvt.h" +#include "MCerPhotPix.h" +#include "MMuonSearchPar.h" +#include "MBinning.h" + +using namespace std; + +ClassImp(MMuonCalibPar); + +// -------------------------------------------------------------------------- +// +// Default constructor. +// +MMuonCalibPar::MMuonCalibPar(const char *name, const char *title) +{ + fName = name ? name : "MMuonCalibPar"; + fTitle = title ? title : "Muon calibration parameters"; + + fHistPhi.SetName("HistPhi"); + fHistPhi.SetTitle("HistPhi"); + fHistPhi.SetXTitle("phi [deg.]"); + fHistPhi.SetYTitle("sum of ADC"); + fHistPhi.SetDirectory(NULL); + fHistPhi.SetFillStyle(4000); + fHistPhi.UseCurrentStyle(); + + fHistWid.SetName("HistWid"); + fHistWid.SetTitle("HistWid"); + fHistWid.SetXTitle("distance from the ring center [deg.]"); + fHistWid.SetYTitle("sum of ADC"); + fHistWid.SetDirectory(NULL); + fHistWid.SetFillStyle(4000); + fHistWid.UseCurrentStyle(); + + fKeepHist = kFALSE; // normally histgram is not kept + fEnableImpactCalc = kFALSE; // By default the calculation of impact parameter is skipped. + fDisablePreCuts = kFALSE; // By default the pre cuts will be applied. + fUseCleanForWid = kFALSE; // By default all the pixels will be used for the histogram of arc width. + + fMargin = 60.; // in mm + fArcPhiThres = 100.; + fArcWidThres = 100.; + fArcPhiBinNum = 20; + fArcPhiHistStartVal = -180.; // deg. + fArcPhiHistEndVal = 180.; // deg. + fArcWidBinNum = 28; + fArcWidHistStartVal = 0.3; // deg. + fArcWidHistEndVal = 1.7; // deg. +} + +// -------------------------------------------------------------------------- +// +void MMuonCalibPar::Reset() +{ + fArcLen = -1.; + fArcPhi = 0.; + fArcWid = -1.; + fChiArcPhi = -1.; + fChiArcWid = -1.; + fMuonSize = 0.; + fEstImpact = -1.; + fUseUnmap = kFALSE; + fPeakPhi = 0.; +} + +// -------------------------------------------------------------------------- +// +// This function fill the histograms in order to get muon parameters. +// For the evaluation of the Arc Width, we use only the signals in the inner part. +// You can use the image after the cleaning by using the function of UseCleanForWid(). +// See the manual of MMuonCalibParCalc. +// +void MMuonCalibPar::FillHist +( const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch) +{ + // preparation for a histgram + MBinning binsphi; + binsphi.SetEdges(fArcPhiBinNum, fArcPhiHistStartVal, fArcPhiHistEndVal); + binsphi.Apply(fHistPhi); + + MBinning binswid; + binswid.SetEdges(fArcWidBinNum, fArcWidHistStartVal, fArcWidHistEndVal); + binswid.Apply(fHistWid); + + const Int_t entries = evt.GetNumPixels(); + + // the position of the center of a muon ring + const Float_t cenx = musearch.GetCenX(); + const Float_t ceny = musearch.GetCenY(); + + for (Int_t i=0; i0) + ang *= -1.0; + + // if the signal is not near the estimated circle, it is ignored. + if(dist < musearch.GetRad() + fMargin && dist > musearch.GetRad() - fMargin) + { + // check whether ummapped pixel is used or not. + // if it is so, ingnore the pixel information since the pixels totally deteriorate the muon information. + if(pix.IsPixelUnmapped()) + { + fUseUnmap = kTRUE; + continue; + } + fHistPhi.Fill(ang*kRad2Deg, pix.GetNumPhotons()); + fMuonSize += pix.GetNumPhotons(); + } + + if(pix.GetPixId()>397) + continue; // use only the inner pixles + + if(fUseCleanForWid) + { + if(!pix.IsPixelUsed()) + continue; + } + + fHistWid.Fill(dist*geom.GetConvMm2Deg(), pix.GetNumPhotons()); + } + + + // error estimation (temporaly) + // The error is estimated from the signal. In order to do so, we have to + // once convert the signal from ADC to photo-electron. Then we can get + // the fluctuation such as F-factor*sqrt(phe). + // Up to now, the error of pedestal is not taken into accout. This is not of + // course correct. We will include this soon. + Double_t ADC2PhEl = 0.14; + Double_t Ffactor = 1.4; + for(Int_t i=0; ifArcPhiBinNum) + { + id-=(fArcPhiBinNum); + } + if(id<=0) + { + id+=(fArcPhiBinNum); + } + fHistPhi.SetBinContent(i,tmp[id]); + } + maxbin = (Int_t)((Float_t)fArcPhiBinNum/2.)+1; + + // Determination of fitting region + // The threshold is fixed with 100 [photons or ADC] in a bin. Therefore, + // if you change the bin number, YOU HAVE TO CHANGE THIS VALUE!!! + Float_t startfitval = 0.; + Float_t endfitval = 0.; + Bool_t IsInMaxim = kFALSE; + Int_t effbinnum = 0; + for(Int_t i=1; i fArcPhiThres && content_pre < fArcPhiThres) + { + startfitval = (Float_t)(i-1)*convbin2val+fArcPhiHistStartVal; + } + if(i==maxbin) + IsInMaxim = kTRUE; + + if(content < fArcPhiThres && IsInMaxim == kTRUE) + { + endfitval = (Float_t)(i-1)*convbin2val+fArcPhiHistStartVal; + break; + } + endfitval = fArcPhiHistEndVal; + } + + effbinnum = (Int_t)((endfitval-startfitval)/convbin2val); + + fArcPhi = effbinnum*convbin2val; + fArcLen = fArcPhi*3.1415926/180.*musearch.GetRad()*geom.GetConvMm2Deg(); + + if(fEnableImpactCalc) + CalcImpact(geom, musearch, effbinnum, startfitval, endfitval); +} + +// -------------------------------------------------------------------------- +// +// An impact parameter is calculated by fitting the histogram of photon +// distribution along the circle with a theoritical model. +// (See G. Vacanti et. al., Astroparticle Physics 2, 1994, 1-11. +// The function (6) is used here.) +// +// By default this calculation is suppressed because this calculation is +// very time consuming. If you want to calculate an impact parameter, +// you can call the function of EnableImpactCalc(). +// +void MMuonCalibPar::CalcImpact +( const MGeomCam &geom, const MMuonSearchPar &musearch, + Int_t effbinnum, Float_t startfitval, Float_t endfitval) +{ + // Fit the distribution with Vacanti function. The function is different + // for the impact parameter of inside or outside of our reflector. + // Then two different functions are applied to the photon distribution, + // and the one which give us smaller chisquare value is taken as a + // proper one. + Double_t val1,err1,val2,err2; + // impact parameter inside mirror radius (8.5m) + TString func1; + Float_t tmpval = musearch.GetRad()*geom.GetConvMm2Deg()*3.1415926/180.; + tmpval = sin(2.*tmpval)*8.5; + func1 += "[0]*"; + func1 += tmpval; + func1 += "*(sqrt(1.-([1]/8.5)**2*sin((x-[2])*3.1415926/180.)**2)+([1]/8.5)*cos((x-[2])*3.1415926/180.))"; + + TF1 f1("f1",func1,startfitval,endfitval); + f1.SetParameters(2000,3,0); + f1.SetParLimits(1,0,8.5); + f1.SetParLimits(2,-180.,180.); + + if(fKeepHist) + { + fHistPhi.Fit("f1","RQEM"); + } + else + { + fHistPhi.Fit("f1","RQEM0"); + } + + Float_t chi1 = -1; + Float_t chi2 = -1; + if(effbinnum>3) + chi1 = f1.GetChisquare()/((Float_t)(effbinnum-3)); + + gMinuit->GetParameter(1,val1,err1); // get the estimated IP + Float_t estip1 = val1; + + // impact parameter beyond mirror area (8.5m) + TString func2; + Float_t tmpval2 = musearch.GetRad()*geom.GetConvMm2Deg()*3.1415926/180.; + tmpval2 = sin(2.*tmpval2)*8.5*2.; + func2 += "[0]*"; + func2 += tmpval2; + func2 += "*sqrt(1.-(([1]/8.5)*sin((x-[2])*3.1415926/180.))**2)"; + + TF1 f2("f2",func2,startfitval,endfitval); + f2.SetParameters(2000,20,0); + f2.SetParLimits(1,8.5,300.); + f2.SetParLimits(2,-180.,180.); + + if(fKeepHist) + { + fHistPhi.Fit("f2","RQEM+"); + } + else + { + fHistPhi.Fit("f2","RQEM0+"); + } + + if(effbinnum>3) + chi2 = f2.GetChisquare()/((Float_t)(effbinnum-3)); + + gMinuit->GetParameter(1,val2,err2); // get the estimated IP + Float_t estip2 = val2; + + if(effbinnum<=3) + { + fEstImpact = -1.; + } + if(chi2 > chi1) + { + fEstImpact = estip1; + fChiArcPhi = chi1; + } + else + { + fEstImpact = estip2; + fChiArcPhi = chi2; + } +} + +// -------------------------------------------------------------------------- +// +// Photon distribution of distance from the center of estimated ring is +// fitted in order to get some more information such as ARC WIDTH which +// can represent to the PSF of our reflector. +// +Float_t MMuonCalibPar::CalcWid +(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch) +{ + Float_t convbin2val = (fArcWidHistEndVal - fArcWidHistStartVal) + /(Float_t)fArcWidBinNum; + + // determination of fitting region + Int_t maxbin = fHistWid.GetMaximumBin(); + Float_t startfitval = 0.; + Float_t endfitval = 0.; + Bool_t IsInMaxim = kFALSE; + Int_t effbinnum = 0; + for(Int_t i=1; i fArcWidThres) + effbinnum++; + + if(content > fArcWidThres && content_pre < fArcWidThres) + { + startfitval = (Float_t)(i-4)*convbin2val + fArcWidHistStartVal; + if(startfitval<0.) startfitval = 0.; + } + if(i==maxbin) + IsInMaxim = kTRUE; + + if(content < fArcWidThres && IsInMaxim == kTRUE) + { + endfitval = (Float_t)(i+2)*convbin2val + fArcWidHistStartVal; + if(endfitval>180.) endfitval = 180.; + break; + } + endfitval = fArcWidHistEndVal; + } + effbinnum = (Int_t)((endfitval-startfitval)/convbin2val); + + TF1 f1("f1","gaus",startfitval,endfitval); + + if(fKeepHist) + { + fHistWid.Fit("f1","QR","",startfitval,endfitval); + } + else + { + fHistWid.Fit("f1","QR0","",startfitval,endfitval); + } + + if(effbinnum>3) + fChiArcWid = f1.GetChisquare()/((Float_t)(effbinnum-3)); + + Double_t val,err; + gMinuit->GetParameter(2,val,err); // get the sigma value + + return val; +} + +// -------------------------------------------------------------------------- +// +// Calculation of muon parameters +// +Int_t MMuonCalibPar::Calc +(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch) +{ + // sanity check + if(evt.GetNumPixels() < 3) + return kCONTINUE; + + // if an event does not seem to be like muon, it will be skipped. + if(musearch.IsNoMuon()) + return kCONTINUE; + + // Pre Cuts 1 + if(!fDisablePreCuts) + { + if(musearch.GetRad() < 180. || musearch.GetRad() > 400.) + return kCONTINUE; + if(musearch.GetDev() > 50.) + return kCONTINUE; + } + + Reset(); + + FillHist(geom,evt,musearch); + + CalcPhi(geom,evt,musearch); + + // Pre Cuts 2 + if(!fDisablePreCuts) + { + if(fMuonSize < 2000. || fArcPhi < 150.) + return kCONTINUE; + } + + fArcWid = CalcWid(geom,evt,musearch); + + // Pre Cuts 3 + if(!fDisablePreCuts) + { + if(fArcWid < 0.16) + return kCONTINUE; + } + + SetReadyToSave(); + + if(!fKeepHist){ + fHistPhi.Reset(); + fHistWid.Reset(); + } + + return kTRUE; +} + +void MMuonCalibPar::Print(Option_t *) const +{ + *fLog << all; + *fLog << "Muon Parameters (" << GetName() << ")" << endl; + *fLog << " - Arc Len. [deg.] = " << fArcLen << endl; + *fLog << " - Arc Phi [deg.] = " << fArcPhi << endl; + *fLog << " - Arc Wid. [deg.] = " << fArcWid << endl; + *fLog << " - Chi Arc Phi [x2/ndf]= " << fChiArcPhi << endl; + *fLog << " - Chi Arc Wid [x2/ndf]= " << fChiArcWid << endl; + *fLog << " - Est. I. P. [m] = " << fEstImpact << endl; + *fLog << " - Size of muon = " << fMuonSize << endl; + *fLog << " - Peak Phi [deg.] = " << fPeakPhi << endl; + *fLog << " - UseUnmap = " << fUseUnmap << endl; +} + + + + Index: trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.h =================================================================== --- trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.h (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MMuonCalibPar.h (revision 5173) @@ -0,0 +1,99 @@ +#ifndef MARS_MMuonCalibPar +#define MARS_MMuonCalibPar + +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TH1 +#include +#endif + +class MGeomCam; +class MCerPhotEvt; +class MMuonSearchPar; + +class MMuonCalibPar : public MParContainer +{ +private: + Float_t fArcLen; // An arc length of a muon along the arc [deg.] + Float_t fArcPhi; // A opening angle of a muon arc [deg.] + Float_t fArcWid; // A width of a muon [deg.] (1 sigma of gaussian fit) + Float_t fChiArcPhi; // A chisquare value of the cosine fit for arc phi + Float_t fChiArcWid; // A chisquare value of the cosine fit for arc wid + Float_t fMuonSize; // A SIZE of muon which is defined as a SIZE around the estimated circle + Float_t fEstImpact; // An estimated impact parameter from the photon distribution along the arc image + Bool_t fKeepHist; // A flag to keep histgram + 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 + Bool_t fUseUnmap; // This is a flag to know the Unmapped pixels are used. Refer to the class of MImgCleanStd + Float_t fPeakPhi; // The angle which indicates the peak position in the estimated circle + Float_t fArcPhiThres; // The threshold value to define arc phi + Float_t fArcWidThres; // The threshold value to define arc width + 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. + Int_t fArcWidBinNum; // The bin number for the histogram of arc wid + Float_t fArcPhiHistStartVal; // The starting value for the histogram of arc phi + Float_t fArcPhiHistEndVal; // The end value for the histogram of arc phi + Float_t fArcWidHistStartVal; // The starting value for the histogram of arc width + Float_t fArcWidHistEndVal; // The end value for the histogram of arc width + Float_t fEnableImpactCalc; // If true, the impact calculation will be done, which will consume a lot of time. + Float_t fDisablePreCuts; // If true, the pre cuts to select muons for the calibration will be disabled. + Float_t fUseCleanForWid; // If true, the only signal after image cleaningwill be used for the histogram of arc width + + TH1F fHistPhi; // Histogram of photon distribution along the arc. + TH1F fHistWid; // Histogram of radial photon distribution of the arc. + +public: + MMuonCalibPar(const char *name=NULL, const char *title=NULL); + + void Reset(); + + Float_t GetArcLen() const { return fArcLen; } + Float_t GetArcPhi() const { return fArcPhi; } + Float_t GetArcWid() const { return fArcWid; } + Float_t GetChiArcPhi() const { return fChiArcPhi; } + Float_t GetChiArcWid() const { return fChiArcWid; } + Float_t GetMargin() const { return fMargin; } + Float_t GetMuonSize() const { return fMuonSize; } + Float_t GetEstImpact() const { return fEstImpact; } + Bool_t IsUseUnmap() const { return fUseUnmap; } + Float_t GetPeakPhi() const { return fPeakPhi; } + Float_t GetArcPhiThres() const { return fArcPhiThres; } + Float_t GetArcWidThres() const { return fArcWidThres; } + Float_t GetArcPhiBinNum() const { return fArcPhiBinNum; } + Float_t GetArcWidBinNum() const { return fArcWidBinNum; } + TH1F &GetHistPhi() { return fHistPhi; } + TH1F &GetHistWid() { return fHistWid; } + + void SetMargin(Float_t margin) { fMargin = margin; } + void SetArcPhiThres(Float_t thres) { fArcPhiThres = thres; } + void SetArcWidThres(Float_t thres) { fArcWidThres = thres; } + void SetArcPhiBinNum(Int_t num) { fArcPhiBinNum = num; } + void SetArcWidBinNum(Int_t num) { fArcWidBinNum = num; } + + void KeepHist() { fKeepHist = kTRUE; } + Bool_t IsKeepHist() { return fKeepHist; } + + void EnableImpactCalc() { fEnableImpactCalc = kTRUE; } + Bool_t IsEnableImpactCalc() { return fEnableImpactCalc; } + void DisablePreCuts() { fDisablePreCuts = kTRUE; } + Bool_t IsDisablePreCuts() { return fDisablePreCuts; } + void UseCleanForWid() { fUseCleanForWid = kTRUE; } + Bool_t IsUseCleanForWid() { return fUseCleanForWid; } + + void Print(Option_t *opt=NULL) const; + + void FillHist(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch); + void CalcPhi(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch); + void CalcImpact(const MGeomCam &geom, const MMuonSearchPar &musearch, + Int_t effbinnum, Float_t startfitval, Float_t endfitval); + Float_t CalcWid(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch); + Int_t Calc(const MGeomCam &geom, const MCerPhotEvt &evt, + const MMuonSearchPar &musearch); + + ClassDef(MMuonCalibPar, 3) // Container to hold muon calibration parameters +}; + +#endif Index: trunk/MagicSoft/Mars/mmuon/MMuonSearchPar.cc =================================================================== --- trunk/MagicSoft/Mars/mmuon/MMuonSearchPar.cc (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MMuonSearchPar.cc (revision 5173) @@ -0,0 +1,303 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Keiichi Mase 09/2004 +! Markus Meyer 09/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MMuonSearchPar +// +// Storage Container for muon +// +// This class is the container for muon parameters. Actually, in this class, +// muons are searched by fitting the image with a circle. (This function will +// be called by using the class of MMuonSearchParCalc.) This container +// especially holds the information of the results of the search (fit of +// a image by a circle). +// +// In order to use further information of muons such as the width of arcs, +// the arc length along it, the muons size. Use the infomation stored in +// MMuonCalibPar. The information will be available by using the task of +// MMuonCalibParCalc. +// +// +// --- How to search muons --- +// (This information is a little bit technical. You can skip to read if you +// don't need the technical information.) +// +// 1. A temporal center position of a circle is determined by using +// the Hillas parameters. Assumed that the center position will be on the +// line which is perpendicular to the longitudinal image axis and the +// distance from the gravity center of the image to the center position of +// a ring is approximately 1 deg. (corresponding to the Cherenkov angle.). +// Therefore, we will have two candidates of the center positions. +// 2. Find the ring radius which gives the minimum RMS between the camera +// images and the estimated circle. +// 3. Select one temporal position which gives smaller RMS as a true temporal +// center position. +// 4. Changing the center position of a circle on the camera plane from the +// determined temporal center position, find the position which gives the +// minimum RMS of the fit. +// +// +// --- Remark --- +// This method to search for muons is not fully optimized yet. However, +// it is good idea to use the temporal estimated center position from +// the Hillas parameters in order to reduce time to search. In addition, +// This method is faster than the MINUIT. +// +// +// Input Containers: +// [MGeomCam] +// [MHillas] +// [MCerPhotEvt] +// +///////////////////////////////////////////////////////////////////////////// +#include "MMuonSearchPar.h" + +#include + +#include "MLog.h" +#include "MLogManip.h" +#include "MHillas.h" +#include "MGeomCam.h" +#include "MGeomPix.h" +#include "MCerPhotEvt.h" +#include "MCerPhotPix.h" +#include "MBinning.h" + +using namespace std; + +ClassImp(MMuonSearchPar); + +// -------------------------------------------------------------------------- +// +// Default constructor. +// +MMuonSearchPar::MMuonSearchPar(const char *name, const char *title) +{ + fName = name ? name : "MMuonSearchPar"; + fTitle = title ? title : "Muon search parameters"; +} + +// -------------------------------------------------------------------------- +// +void MMuonSearchPar::Reset() +{ + fRad = -1.; + fDev = -1.; + fCenX = 0.; + fCenY = 0.; + fNoMuon = kFALSE; +} + +// -------------------------------------------------------------------------- +// +// Get the tempolary center of a ring from the Hillas parameters. +// Two candidates of the position is returened. +// +void MMuonSearchPar::CalcTempCenter(const MHillas &hillas, + Float_t *xtmp1, Float_t *ytmp1, Float_t *xtmp2, Float_t *ytmp2) +{ + Float_t a,dx,dy; + Float_t tmp_r = 300.; // assume that the temporal cherenkov angle is 1 deg. (300 mm). + + a = tan(hillas.GetDelta()); + + dx = a/sqrt(tmp_r+a*a)/3.; + dy = -tmp_r/sqrt(1+a*a)/3.; + + *xtmp1 = hillas.GetMeanX() + dx; + *ytmp1 = hillas.GetMeanY() + dy; + *xtmp2 = hillas.GetMeanX() - dx; + *ytmp2 = hillas.GetMeanY() - dy; +} + +// -------------------------------------------------------------------------- +// +// This function gives you the ring radius fitted best to the camera image +// and its RMS for the input position. +// +Bool_t MMuonSearchPar::CalcRadius(const MGeomCam &geom, const MCerPhotEvt &evt, + Float_t x, Float_t y, Float_t *r, Float_t *sigma) +{ + Float_t mean_r=0., dev_r=0., sums=0., tmp=0.; + + const Int_t entries = evt.GetNumPixels(); + + for (Int_t i=0; i 360000.) + { + *new_sigma=sigma; + *opt_rad=rad_tmp; + *newx=x; *newy=y; + fNoMuon = kTRUE; + break; + } + if(CalcRadius(geom,evt,x,y+delta,&rad_tmp,&sig_tmp)) + { + if(sig_tmp +#endif + +#ifndef ROOT_TArrayI +#include +#endif + +class MHillas; +class MGeomCam; +class MCerPhotEvt; + +class MMuonSearchPar : public MParContainer +{ +private: + Float_t fRad; // An estimated radius of the muon ring [mm] + Float_t fDev; // The standard deviation from the estimated ring [mm] + Float_t fCenX; // An estimated center position in X of the muon ring [mm] + Float_t fCenY; // An estimated center position in Y of the muon ring [mm] + Bool_t fNoMuon; // if the radius is estimated above 600 mm (2 deg.), assumed it's not muon. + +public: + MMuonSearchPar(const char *name=NULL, const char *title=NULL); + + void Reset(); + + Float_t GetRad() const { return fRad; } + Float_t GetDev() const { return fDev; } + Float_t GetCenX() const { return fCenX; } + Float_t GetCenY() const { return fCenY; } + Bool_t IsNoMuon() const { return fNoMuon; } + + void Print(Option_t *opt=NULL) const; + void Print(const MGeomCam &geom, Option_t *opt=NULL) const; + void CalcTempCenter(const MHillas &hillas, Float_t *xtmp1, + Float_t *ytmp1, Float_t *xtmp2, Float_t *ytmp2); + Bool_t CalcRadius(const MGeomCam &geom, const MCerPhotEvt &evt, Float_t x, + Float_t y, Float_t *r, Float_t *sigma); + void CalcMinimumDev(const MGeomCam &geom, const MCerPhotEvt &evt, + Float_t x, Float_t y, Float_t xcog, + Float_t ycog, Float_t sigma, Float_t *opt_rad, + Float_t *new_sigma, Float_t *newx, Float_t *newy); + void Calc(const MGeomCam &geom, const MCerPhotEvt &evt, + const MHillas &hillas); + + ClassDef(MMuonSearchPar, 1) // Container to hold muon search parameters +}; + +#endif Index: trunk/MagicSoft/Mars/mmuon/MuonCint.cc =================================================================== --- trunk/MagicSoft/Mars/mmuon/MuonCint.cc (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MuonCint.cc (revision 5173) @@ -0,0 +1,1301 @@ +// +// File generated by /cernroot/3_05_07/root/bin/rootcint at Tue Oct 5 14:38:21 2004. +// Do NOT change. Changes will be lost next time file is generated +// + +#include "RConfig.h" +#if !defined(R__ACCESS_IN_SYMBOL) +//Break the privacy of classes -- Disabled for the moment +#define private public +#define protected public +#endif + +#include "MuonCint.h" +#include "TClass.h" +#include "TBuffer.h" +#include "TMemberInspector.h" +#include "TError.h" + +#ifndef G__ROOT +#define G__ROOT +#endif + +// Since CINT ignores the std namespace, we need to do so in this file. +namespace std {} using namespace std; + +#include "RtypesImp.h" + +namespace ROOT { + namespace Shadow { + } // Of namespace ROOT::Shadow +} // Of namespace ROOT + +namespace ROOT { + void MMuonSearchPar_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MMuonSearchPar_IsA(const void*); + void *new_MMuonSearchPar(void *p = 0); + void *newArray_MMuonSearchPar(Long_t size); + void delete_MMuonSearchPar(void *p); + void deleteArray_MMuonSearchPar(void *p); + void destruct_MMuonSearchPar(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MMuonSearchPar*) + { + MMuonSearchPar *ptr = 0; + static ROOT::TGenericClassInfo + instance("MMuonSearchPar", MMuonSearchPar::Class_Version(), "MMuonSearchPar.h", 21, + typeid(MMuonSearchPar), DefineBehavior(ptr, ptr), + &::MMuonSearchPar::Dictionary, &MMuonSearchPar_IsA, 4); + instance.SetNew(&new_MMuonSearchPar); + instance.SetNewArray(&newArray_MMuonSearchPar); + instance.SetDelete(&delete_MMuonSearchPar); + instance.SetDeleteArray(&deleteArray_MMuonSearchPar); + instance.SetDestructor(&destruct_MMuonSearchPar); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MMuonSearchPar*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +namespace ROOT { + void MMuonCalibPar_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MMuonCalibPar_IsA(const void*); + void *new_MMuonCalibPar(void *p = 0); + void *newArray_MMuonCalibPar(Long_t size); + void delete_MMuonCalibPar(void *p); + void deleteArray_MMuonCalibPar(void *p); + void destruct_MMuonCalibPar(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MMuonCalibPar*) + { + MMuonCalibPar *ptr = 0; + static ROOT::TGenericClassInfo + instance("MMuonCalibPar", MMuonCalibPar::Class_Version(), "MMuonCalibPar.h", 17, + typeid(MMuonCalibPar), DefineBehavior(ptr, ptr), + &::MMuonCalibPar::Dictionary, &MMuonCalibPar_IsA, 4); + instance.SetNew(&new_MMuonCalibPar); + instance.SetNewArray(&newArray_MMuonCalibPar); + instance.SetDelete(&delete_MMuonCalibPar); + instance.SetDeleteArray(&deleteArray_MMuonCalibPar); + instance.SetDestructor(&destruct_MMuonCalibPar); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MMuonCalibPar*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +//______________________________________________________________________________ +TClass *MMuonSearchPar::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MMuonSearchPar::Class_Name() +{ + return "MMuonSearchPar"; +} + +//______________________________________________________________________________ +const char *MMuonSearchPar::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MMuonSearchPar*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MMuonSearchPar::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MMuonSearchPar*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MMuonSearchPar::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MMuonSearchPar*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MMuonSearchPar::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MMuonSearchPar*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *MMuonCalibPar::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MMuonCalibPar::Class_Name() +{ + return "MMuonCalibPar"; +} + +//______________________________________________________________________________ +const char *MMuonCalibPar::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MMuonCalibPar*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MMuonCalibPar::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MMuonCalibPar*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MMuonCalibPar::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MMuonCalibPar*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MMuonCalibPar::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MMuonCalibPar*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +void MMuonSearchPar::Streamer(TBuffer &R__b) +{ + // Stream an object of class MMuonSearchPar. + + if (R__b.IsReading()) { + MMuonSearchPar::Class()->ReadBuffer(R__b, this); + } else { + MMuonSearchPar::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MMuonSearchPar::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MMuonSearchPar. + + TClass *R__cl = MMuonSearchPar::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fRad", &fRad); + R__insp.Inspect(R__cl, R__parent, "fDev", &fDev); + R__insp.Inspect(R__cl, R__parent, "fCenX", &fCenX); + R__insp.Inspect(R__cl, R__parent, "fCenY", &fCenY); + R__insp.Inspect(R__cl, R__parent, "fNoMuon", &fNoMuon); + MParContainer::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MMuonSearchPar_IsA(const void *obj) { + return ((::MMuonSearchPar*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MMuonSearchPar(void *p) { + return p ? new(p) ::MMuonSearchPar : new ::MMuonSearchPar; + } + void *newArray_MMuonSearchPar(Long_t size) { + return new ::MMuonSearchPar[size]; + } + // Wrapper around operator delete + void delete_MMuonSearchPar(void *p) { + delete ((::MMuonSearchPar*)p); + } + void deleteArray_MMuonSearchPar(void *p) { + delete [] ((::MMuonSearchPar*)p); + } + void destruct_MMuonSearchPar(void *p) { + typedef ::MMuonSearchPar current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MMuonSearchPar + +//______________________________________________________________________________ +void R__MMuonCalibPar_fHistPhi(TBuffer &R__b, void *R__p, int) +{ + TH1F &fHistPhi = *(TH1F *)R__p; + if (R__b.IsReading()) { + fHistPhi.Streamer(R__b); + } else { + fHistPhi.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void R__MMuonCalibPar_fHistWid(TBuffer &R__b, void *R__p, int) +{ + TH1F &fHistWid = *(TH1F *)R__p; + if (R__b.IsReading()) { + fHistWid.Streamer(R__b); + } else { + fHistWid.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MMuonCalibPar::Streamer(TBuffer &R__b) +{ + // Stream an object of class MMuonCalibPar. + + if (R__b.IsReading()) { + MMuonCalibPar::Class()->ReadBuffer(R__b, this); + } else { + MMuonCalibPar::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MMuonCalibPar::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MMuonCalibPar. + + TClass *R__cl = MMuonCalibPar::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fArcLen", &fArcLen); + R__insp.Inspect(R__cl, R__parent, "fArcPhi", &fArcPhi); + R__insp.Inspect(R__cl, R__parent, "fArcWid", &fArcWid); + R__insp.Inspect(R__cl, R__parent, "fChiArcPhi", &fChiArcPhi); + R__insp.Inspect(R__cl, R__parent, "fChiArcWid", &fChiArcWid); + R__insp.Inspect(R__cl, R__parent, "fMuonSize", &fMuonSize); + R__insp.Inspect(R__cl, R__parent, "fEstImpact", &fEstImpact); + R__insp.Inspect(R__cl, R__parent, "fKeepHist", &fKeepHist); + R__insp.Inspect(R__cl, R__parent, "fMargin", &fMargin); + R__insp.Inspect(R__cl, R__parent, "fUseUnmap", &fUseUnmap); + R__insp.Inspect(R__cl, R__parent, "fPeakPhi", &fPeakPhi); + R__insp.Inspect(R__cl, R__parent, "fArcPhiThres", &fArcPhiThres); + R__insp.Inspect(R__cl, R__parent, "fArcWidThres", &fArcWidThres); + R__insp.Inspect(R__cl, R__parent, "fArcPhiBinNum", &fArcPhiBinNum); + R__insp.Inspect(R__cl, R__parent, "fArcWidBinNum", &fArcWidBinNum); + R__insp.Inspect(R__cl, R__parent, "fArcPhiHistStartVal", &fArcPhiHistStartVal); + R__insp.Inspect(R__cl, R__parent, "fArcPhiHistEndVal", &fArcPhiHistEndVal); + R__insp.Inspect(R__cl, R__parent, "fArcWidHistStartVal", &fArcWidHistStartVal); + R__insp.Inspect(R__cl, R__parent, "fArcWidHistEndVal", &fArcWidHistEndVal); + R__insp.Inspect(R__cl, R__parent, "fEnableImpactCalc", &fEnableImpactCalc); + R__insp.Inspect(R__cl, R__parent, "fDisablePreCuts", &fDisablePreCuts); + R__insp.Inspect(R__cl, R__parent, "fUseCleanForWid", &fUseCleanForWid); + R__insp.Inspect(R__cl, R__parent, "fHistPhi", &fHistPhi); + fHistPhi.ShowMembers(R__insp, strcat(R__parent,"fHistPhi.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fHistPhi",R__MMuonCalibPar_fHistPhi); + R__insp.Inspect(R__cl, R__parent, "fHistWid", &fHistWid); + fHistWid.ShowMembers(R__insp, strcat(R__parent,"fHistWid.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fHistWid",R__MMuonCalibPar_fHistWid); + MParContainer::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MMuonCalibPar_IsA(const void *obj) { + return ((::MMuonCalibPar*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MMuonCalibPar(void *p) { + return p ? new(p) ::MMuonCalibPar : new ::MMuonCalibPar; + } + void *newArray_MMuonCalibPar(Long_t size) { + return new ::MMuonCalibPar[size]; + } + // Wrapper around operator delete + void delete_MMuonCalibPar(void *p) { + delete ((::MMuonCalibPar*)p); + } + void deleteArray_MMuonCalibPar(void *p) { + delete [] ((::MMuonCalibPar*)p); + } + void destruct_MMuonCalibPar(void *p) { + typedef ::MMuonCalibPar current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MMuonCalibPar + +/******************************************************** +* MuonCint.cc +********************************************************/ + +#ifdef G__MEMTEST +#undef malloc +#undef free +#endif + +extern "C" void G__cpp_reset_tagtableMuonCint(); + +extern "C" void G__set_cpp_environmentMuonCint() { + G__add_compiledheader("TROOT.h"); + G__add_compiledheader("TMemberInspector.h"); + G__add_compiledheader("MMuonSearchPar.h"); + G__add_compiledheader("MMuonCalibPar.h"); + G__add_compiledheader("MuonIncl.h"); + G__cpp_reset_tagtableMuonCint(); +} +class G__MuonCintdOcc_tag {}; + +void* operator new(size_t size,G__MuonCintdOcc_tag* p) { + if(p && G__PVOID!=G__getgvp()) return((void*)p); +#ifndef G__ROOT + return(malloc(size)); +#else + return(::operator new(size)); +#endif +} + +/* dummy, for exception */ +#ifdef G__EH_DUMMY_DELETE +void operator delete(void *p,G__MuonCintdOcc_tag* x) { + if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return; +#ifndef G__ROOT + free(p); +#else + ::operator delete(p); +#endif +} +#endif + +static void G__operator_delete(void *p) { + if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return; +#ifndef G__ROOT + free(p); +#else + ::operator delete(p); +#endif +} + +void G__DELDMY_MuonCintdOcc() { G__operator_delete(0); } + +extern "C" int G__cpp_dllrevMuonCint() { return(30051515); } + +/********************************************************* +* Member function Interface Method +*********************************************************/ + +/* MMuonSearchPar */ +static int G__MuonCint_159_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MMuonSearchPar *p=NULL; + switch(libp->paran) { + case 2: + p = new MMuonSearchPar((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])); + break; + case 1: + p = new MMuonSearchPar((const char*)G__int(libp->para[0])); + break; + case 0: + if(G__getaryconstruct()) p=new MMuonSearchPar[G__getaryconstruct()]; + else p=new MMuonSearchPar; + break; + } + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->Reset(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonSearchPar*)(G__getstructoffset()))->GetRad()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonSearchPar*)(G__getstructoffset()))->GetDev()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonSearchPar*)(G__getstructoffset()))->GetCenX()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonSearchPar*)(G__getstructoffset()))->GetCenY()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((const MMuonSearchPar*)(G__getstructoffset()))->IsNoMuon()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 1: + G__setnull(result7); + ((const MMuonSearchPar*)(G__getstructoffset()))->Print((const Option_t*)G__int(libp->para[0])); + break; + case 0: + G__setnull(result7); + ((const MMuonSearchPar*)(G__getstructoffset()))->Print(); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 2: + G__setnull(result7); + ((const MMuonSearchPar*)(G__getstructoffset()))->Print(*(MGeomCam*)libp->para[0].ref,(const Option_t*)G__int(libp->para[1])); + break; + case 1: + G__setnull(result7); + ((const MMuonSearchPar*)(G__getstructoffset()))->Print(*(MGeomCam*)libp->para[0].ref); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->CalcTempCenter(*(MHillas*)libp->para[0].ref,(Float_t*)G__int(libp->para[1]) +,(Float_t*)G__int(libp->para[2]),(Float_t*)G__int(libp->para[3]) +,(Float_t*)G__int(libp->para[4])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((MMuonSearchPar*)(G__getstructoffset()))->CalcRadius(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,(Float_t)G__double(libp->para[2]),(Float_t)G__double(libp->para[3]) +,(Float_t*)G__int(libp->para[4]),(Float_t*)G__int(libp->para[5]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->CalcMinimumDev( +*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,(Float_t)G__double(libp->para[2]),(Float_t)G__double(libp->para[3]) +,(Float_t)G__double(libp->para[4]),(Float_t)G__double(libp->para[5]) +,(Float_t)G__double(libp->para[6]),(Float_t*)G__int(libp->para[7]) +,(Float_t*)G__int(libp->para[8]),(Float_t*)G__int(libp->para[9]) +,(Float_t*)G__int(libp->para[10])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->Calc(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,*(MHillas*)libp->para[2].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MMuonSearchPar::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonSearchPar::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MMuonSearchPar::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MMuonSearchPar::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MMuonSearchPar*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonSearchPar*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonSearchPar::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MMuonSearchPar::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonSearchPar::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_159_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MMuonSearchPar::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__MuonCint_159_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MMuonSearchPar *p; + p=new MMuonSearchPar(*(MMuonSearchPar*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MMuonSearchPar G__TMMuonSearchPar; +static int G__MuonCint_159_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MMuonSearchPar *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MMuonSearchPar *)((G__getstructoffset())+sizeof(MMuonSearchPar)*i); + else delete (MMuonSearchPar *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* MMuonCalibPar */ +static int G__MuonCint_160_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MMuonCalibPar *p=NULL; + switch(libp->paran) { + case 2: + p = new MMuonCalibPar((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1])); + break; + case 1: + p = new MMuonCalibPar((const char*)G__int(libp->para[0])); + break; + case 0: + if(G__getaryconstruct()) p=new MMuonCalibPar[G__getaryconstruct()]; + else p=new MMuonCalibPar; + break; + } + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->Reset(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcLen()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcPhi()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcWid()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetChiArcPhi()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetChiArcWid()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetMargin()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetMuonSize()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetEstImpact()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((const MMuonCalibPar*)(G__getstructoffset()))->IsUseUnmap()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetPeakPhi()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcPhiThres()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcWidThres()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcPhiBinNum()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MMuonCalibPar*)(G__getstructoffset()))->GetArcWidBinNum()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + { + const TH1F& obj=((MMuonCalibPar*)(G__getstructoffset()))->GetHistPhi(); + result7->ref=(long)(&obj); result7->obj.i=(long)(&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + { + const TH1F& obj=((MMuonCalibPar*)(G__getstructoffset()))->GetHistWid(); + result7->ref=(long)(&obj); result7->obj.i=(long)(&obj); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->SetMargin((Float_t)G__double(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->SetArcPhiThres((Float_t)G__double(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->SetArcWidThres((Float_t)G__double(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->SetArcPhiBinNum((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->SetArcWidBinNum((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->KeepHist(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_4_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((MMuonCalibPar*)(G__getstructoffset()))->IsKeepHist()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_5_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->EnableImpactCalc(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((MMuonCalibPar*)(G__getstructoffset()))->IsEnableImpactCalc()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->DisablePreCuts(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((MMuonCalibPar*)(G__getstructoffset()))->IsDisablePreCuts()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->UseCleanForWid(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,103,(long)((MMuonCalibPar*)(G__getstructoffset()))->IsUseCleanForWid()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 1: + G__setnull(result7); + ((const MMuonCalibPar*)(G__getstructoffset()))->Print((const Option_t*)G__int(libp->para[0])); + break; + case 0: + G__setnull(result7); + ((const MMuonCalibPar*)(G__getstructoffset()))->Print(); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->FillHist(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,*(MMuonSearchPar*)libp->para[2].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->CalcPhi(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,*(MMuonSearchPar*)libp->para[2].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->CalcImpact(*(MGeomCam*)libp->para[0].ref,*(MMuonSearchPar*)libp->para[1].ref +,(Int_t)G__int(libp->para[2]),(Float_t)G__double(libp->para[3]) +,(Float_t)G__double(libp->para[4])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((MMuonCalibPar*)(G__getstructoffset()))->CalcWid(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,*(MMuonSearchPar*)libp->para[2].ref)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)((MMuonCalibPar*)(G__getstructoffset()))->Calc(*(MGeomCam*)libp->para[0].ref,*(MCerPhotEvt*)libp->para[1].ref +,*(MMuonSearchPar*)libp->para[2].ref)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MMuonCalibPar::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonCalibPar::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_9_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MMuonCalibPar::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_0_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MMuonCalibPar::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_1_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MMuonCalibPar*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_2_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_3_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_4_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MMuonCalibPar*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_5_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonCalibPar::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_6_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MMuonCalibPar::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_7_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MMuonCalibPar::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__MuonCint_160_8_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MMuonCalibPar::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MMuonCalibPar G__TMMuonCalibPar; +static int G__MuonCint_160_9_4(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MMuonCalibPar *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MMuonCalibPar *)((G__getstructoffset())+sizeof(MMuonCalibPar)*i); + else delete (MMuonCalibPar *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* Setting up global function */ + +/********************************************************* +* Member function Stub +*********************************************************/ + +/* MMuonSearchPar */ + +/* MMuonCalibPar */ + +/********************************************************* +* Global function Stub +*********************************************************/ + +/********************************************************* +* Get size of pointer to member function +*********************************************************/ +class G__Sizep2memfuncMuonCint { + public: + G__Sizep2memfuncMuonCint() {p=&G__Sizep2memfuncMuonCint::sizep2memfunc;} + size_t sizep2memfunc() { return(sizeof(p)); } + private: + size_t (G__Sizep2memfuncMuonCint::*p)(); +}; + +size_t G__get_sizep2memfuncMuonCint() +{ + G__Sizep2memfuncMuonCint a; + G__setsizep2memfunc((int)a.sizep2memfunc()); + return((size_t)a.sizep2memfunc()); +} + + +/********************************************************* +* virtual base class offset calculation interface +*********************************************************/ + + /* Setting up class inheritance */ + +/********************************************************* +* Inheritance information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_inheritanceMuonCint() { + + /* Setting up class inheritance */ + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar))) { + MMuonSearchPar *G__Lderived; + G__Lderived=(MMuonSearchPar*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar),G__get_linked_tagnum(&G__MuonCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar),G__get_linked_tagnum(&G__MuonCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar))) { + MMuonCalibPar *G__Lderived; + G__Lderived=(MMuonCalibPar*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar),G__get_linked_tagnum(&G__MuonCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar),G__get_linked_tagnum(&G__MuonCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } +} + +/********************************************************* +* typedef information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_typetableMuonCint() { + + /* Setting up typedef entry */ + G__search_typename2("Int_t",105,-1,0, +-1); + G__setnewtype(-1,"Signed integer 4 bytes (int)",0); + G__search_typename2("Float_t",102,-1,0, +-1); + G__setnewtype(-1,"Float 4 bytes (float)",0); + G__search_typename2("Bool_t",103,-1,0, +-1); + G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0); + G__search_typename2("Version_t",115,-1,0, +-1); + G__setnewtype(-1,"Class version identifier (short)",0); + G__search_typename2("Option_t",99,-1,256, +-1); + G__setnewtype(-1,"Option string (const char)",0); +} + +/********************************************************* +* Data Member information setup/ +*********************************************************/ + + /* Setting up class,struct,union tag member variable */ + + /* MMuonSearchPar */ +static void G__setup_memvarMMuonSearchPar(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar)); + { MMuonSearchPar *p; p=(MMuonSearchPar*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRad=",0,"An estimated radius of the muon ring [mm]"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDev=",0,"The standard deviation from the estimated ring [mm]"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCenX=",0,"An estimated center position in X of the muon ring [mm]"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCenY=",0,"An estimated center position in Y of the muon ring [mm]"); + G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoMuon=",0,"if the radius is estimated above 600 mm (2 deg.), assumed it's not muon."); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* MMuonCalibPar */ +static void G__setup_memvarMMuonCalibPar(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar)); + { MMuonCalibPar *p; p=(MMuonCalibPar*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcLen=",0,"An arc length of a muon along the arc [deg.]"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcPhi=",0,"A opening angle of a muon arc [deg.]"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcWid=",0,"A width of a muon [deg.] (1 sigma of gaussian fit)"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fChiArcPhi=",0,"A chisquare value of the cosine fit for arc phi"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fChiArcWid=",0,"A chisquare value of the cosine fit for arc wid"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMuonSize=",0,"A SIZE of muon which is defined as a SIZE around the estimated circle"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEstImpact=",0,"An estimated impact parameter from the photon distribution along the arc image"); + G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fKeepHist=",0,"A flag to keep histgram"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMargin=",0,"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"); + G__memvar_setup((void*)NULL,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseUnmap=",0,"This is a flag to know the Unmapped pixels are used. Refer to the class of MImgCleanStd"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fPeakPhi=",0,"The angle which indicates the peak position in the estimated circle"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcPhiThres=",0,"The threshold value to define arc phi"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcWidThres=",0,"The threshold value to define arc width"); + G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fArcPhiBinNum=",0,"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."); + G__memvar_setup((void*)NULL,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fArcWidBinNum=",0,"The bin number for the histogram of arc wid"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcPhiHistStartVal=",0,"The starting value for the histogram of arc phi"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcPhiHistEndVal=",0,"The end value for the histogram of arc phi"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcWidHistStartVal=",0,"The starting value for the histogram of arc width"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArcWidHistEndVal=",0,"The end value for the histogram of arc width"); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEnableImpactCalc=",0,"If true, the impact calculation will be done, which will consume a lot of time."); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDisablePreCuts=",0,"If true, the pre cuts to select muons for the calibration will be disabled."); + G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fUseCleanForWid=",0,"If true, the only signal after image cleaningwill be used for the histogram of arc width"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__MuonCintLN_TH1F),-1,-1,4,"fHistPhi=",0,"Histogram of photon distribution along the arc."); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__MuonCintLN_TH1F),-1,-1,4,"fHistWid=",0,"Histogram of radial photon distribution of the arc."); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + +extern "C" void G__cpp_setup_memvarMuonCint() { +} +/*********************************************************** +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +***********************************************************/ + +/********************************************************* +* Member function information setup for each class +*********************************************************/ +static void G__setup_memfuncMMuonSearchPar(void) { + /* MMuonSearchPar */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar)); + G__memfunc_setup("MMuonSearchPar",1381,G__MuonCint_159_0_0,105,G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar),-1,0,2,1,1,0, +"C - - 10 NULL name C - - 10 NULL title",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Reset",515,G__MuonCint_159_1_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("GetRad",567,G__MuonCint_159_2_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetDev",575,G__MuonCint_159_3_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetCenX",654,G__MuonCint_159_4_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetCenY",655,G__MuonCint_159_5_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsNoMuon",792,G__MuonCint_159_6_0,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Print",525,G__MuonCint_159_7_0,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 NULL opt",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Print",525,G__MuonCint_159_8_0,121,-1,-1,0,2,1,1,8, +"u 'MGeomCam' - 11 - geom C - 'Option_t' 10 NULL opt",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcTempCenter",1386,G__MuonCint_159_9_0,121,-1,-1,0,5,1,1,0, +"u 'MHillas' - 11 - hillas F - 'Float_t' 0 - xtmp1 " +"F - 'Float_t' 0 - ytmp1 F - 'Float_t' 0 - xtmp2 " +"F - 'Float_t' 0 - ytmp2",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcRadius",987,G__MuonCint_159_0_1,103,-1,G__defined_typename("Bool_t"),0,6,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"f - 'Float_t' 0 - x f - 'Float_t' 0 - y " +"F - 'Float_t' 0 - r F - 'Float_t' 0 - sigma",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcMinimumDev",1390,G__MuonCint_159_1_1,121,-1,-1,0,11,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"f - 'Float_t' 0 - x f - 'Float_t' 0 - y " +"f - 'Float_t' 0 - xcog f - 'Float_t' 0 - ycog " +"f - 'Float_t' 0 - sigma F - 'Float_t' 0 - opt_rad " +"F - 'Float_t' 0 - new_sigma F - 'Float_t' 0 - newx " +"F - 'Float_t' 0 - newy",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Calc",371,G__MuonCint_159_2_1,121,-1,-1,0,3,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"u 'MHillas' - 11 - hillas",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class",502,G__MuonCint_159_3_1,85,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__MuonCint_159_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__MuonCint_159_5_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__MuonCint_159_6_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__MuonCint_159_7_1,85,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__MuonCint_159_8_1,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__MuonCint_159_9_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__MuonCint_159_0_2,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__MuonCint_159_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__MuonCint_159_2_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__MuonCint_159_3_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__MuonCint_159_4_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MMuonSearchPar",1381,G__MuonCint_159_5_2,(int)('i'),G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar),-1,0,1,1,1,0,"u 'MMuonSearchPar' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MMuonSearchPar",1507,G__MuonCint_159_6_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncMMuonCalibPar(void) { + /* MMuonCalibPar */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar)); + G__memfunc_setup("MMuonCalibPar",1258,G__MuonCint_160_0_0,105,G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar),-1,0,2,1,1,0, +"C - - 10 NULL name C - - 10 NULL title",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Reset",515,G__MuonCint_160_1_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("GetArcLen",853,G__MuonCint_160_2_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcPhi",855,G__MuonCint_160_3_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcWid",858,G__MuonCint_160_4_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetChiArcPhi",1131,G__MuonCint_160_5_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetChiArcWid",1134,G__MuonCint_160_6_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetMargin",894,G__MuonCint_160_7_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetMuonSize",1114,G__MuonCint_160_8_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetEstImpact",1194,G__MuonCint_160_9_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsUseUnmap",1002,G__MuonCint_160_0_1,103,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPeakPhi",962,G__MuonCint_160_1_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcPhiThres",1373,G__MuonCint_160_2_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcWidThres",1376,G__MuonCint_160_3_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcPhiBinNum",1440,G__MuonCint_160_4_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetArcWidBinNum",1443,G__MuonCint_160_5_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetHistPhi",985,G__MuonCint_160_6_1,117,G__get_linked_tagnum(&G__MuonCintLN_TH1F),-1,1,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetHistWid",988,G__MuonCint_160_7_1,117,G__get_linked_tagnum(&G__MuonCintLN_TH1F),-1,1,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("SetMargin",906,G__MuonCint_160_8_1,121,-1,-1,0,1,1,1,0,"f - 'Float_t' 0 - margin",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("SetArcPhiThres",1385,G__MuonCint_160_9_1,121,-1,-1,0,1,1,1,0,"f - 'Float_t' 0 - thres",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("SetArcWidThres",1388,G__MuonCint_160_0_2,121,-1,-1,0,1,1,1,0,"f - 'Float_t' 0 - thres",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("SetArcPhiBinNum",1452,G__MuonCint_160_1_2,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("SetArcWidBinNum",1455,G__MuonCint_160_2_2,121,-1,-1,0,1,1,1,0,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("KeepHist",797,G__MuonCint_160_3_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsKeepHist",985,G__MuonCint_160_4_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("EnableImpactCalc",1560,G__MuonCint_160_5_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsEnableImpactCalc",1748,G__MuonCint_160_6_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DisablePreCuts",1402,G__MuonCint_160_7_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsDisablePreCuts",1590,G__MuonCint_160_8_2,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("UseCleanForWid",1371,G__MuonCint_160_9_2,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsUseCleanForWid",1559,G__MuonCint_160_0_3,103,-1,G__defined_typename("Bool_t"),0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Print",525,G__MuonCint_160_1_3,121,-1,-1,0,1,1,1,8,"C - 'Option_t' 10 NULL opt",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("FillHist",799,G__MuonCint_160_2_3,121,-1,-1,0,3,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"u 'MMuonSearchPar' - 11 - musearch",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcPhi",660,G__MuonCint_160_3_3,121,-1,-1,0,3,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"u 'MMuonSearchPar' - 11 - musearch",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcImpact",977,G__MuonCint_160_4_3,121,-1,-1,0,5,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MMuonSearchPar' - 11 - musearch " +"i - 'Int_t' 0 - effbinnum f - 'Float_t' 0 - startfitval " +"f - 'Float_t' 0 - endfitval",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("CalcWid",663,G__MuonCint_160_5_3,102,-1,G__defined_typename("Float_t"),0,3,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"u 'MMuonSearchPar' - 11 - musearch",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Calc",371,G__MuonCint_160_6_3,105,-1,G__defined_typename("Int_t"),0,3,1,1,0, +"u 'MGeomCam' - 11 - geom u 'MCerPhotEvt' - 11 - evt " +"u 'MMuonSearchPar' - 11 - musearch",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class",502,G__MuonCint_160_7_3,85,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__MuonCint_160_8_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__MuonCint_160_9_3,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__MuonCint_160_0_4,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__MuonCint_160_1_4,85,G__get_linked_tagnum(&G__MuonCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__MuonCint_160_2_4,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__MuonCint_160_3_4,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__MuonCint_160_4_4,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__MuonCint_160_5_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__MuonCint_160_6_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__MuonCint_160_7_4,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__MuonCint_160_8_4,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MMuonCalibPar",1384,G__MuonCint_160_9_4,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + + +/********************************************************* +* Member function information setup +*********************************************************/ +extern "C" void G__cpp_setup_memfuncMuonCint() { +} + +/********************************************************* +* Global variable information setup for each class +*********************************************************/ +static void G__cpp_setup_global0() { + + /* Setting up global variables */ + G__resetplocal(); + +} + +static void G__cpp_setup_global1() { +} + +static void G__cpp_setup_global2() { + + G__resetglobalenv(); +} +extern "C" void G__cpp_setup_globalMuonCint() { + G__cpp_setup_global0(); + G__cpp_setup_global1(); + G__cpp_setup_global2(); +} + +/********************************************************* +* Global function information setup for each class +*********************************************************/ +static void G__cpp_setup_func0() { + G__lastifuncposition(); + +} + +static void G__cpp_setup_func1() { +} + +static void G__cpp_setup_func2() { +} + +static void G__cpp_setup_func3() { + + G__resetifuncposition(); +} + +extern "C" void G__cpp_setup_funcMuonCint() { + G__cpp_setup_func0(); + G__cpp_setup_func1(); + G__cpp_setup_func2(); + G__cpp_setup_func3(); +} + +/********************************************************* +* Class,struct,union,enum tag information setup +*********************************************************/ +/* Setup class/struct taginfo */ +G__linked_taginfo G__MuonCintLN_TClass = { "TClass" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_TBuffer = { "TBuffer" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_TObject = { "TObject" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MParContainer = { "MParContainer" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_TH1F = { "TH1F" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MHillas = { "MHillas" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MGeomCam = { "MGeomCam" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MCerPhotEvt = { "MCerPhotEvt" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MMuonSearchPar = { "MMuonSearchPar" , 99 , -1 }; +G__linked_taginfo G__MuonCintLN_MMuonCalibPar = { "MMuonCalibPar" , 99 , -1 }; + +/* Reset class/struct taginfo */ +extern "C" void G__cpp_reset_tagtableMuonCint() { + G__MuonCintLN_TClass.tagnum = -1 ; + G__MuonCintLN_TBuffer.tagnum = -1 ; + G__MuonCintLN_TMemberInspector.tagnum = -1 ; + G__MuonCintLN_TObject.tagnum = -1 ; + G__MuonCintLN_MParContainer.tagnum = -1 ; + G__MuonCintLN_TH1F.tagnum = -1 ; + G__MuonCintLN_MHillas.tagnum = -1 ; + G__MuonCintLN_MGeomCam.tagnum = -1 ; + G__MuonCintLN_MCerPhotEvt.tagnum = -1 ; + G__MuonCintLN_MMuonSearchPar.tagnum = -1 ; + G__MuonCintLN_MMuonCalibPar.tagnum = -1 ; +} + + +extern "C" void G__cpp_setup_tagtableMuonCint() { + + /* Setting up class,struct,union tag entry */ + G__get_linked_tagnum(&G__MuonCintLN_TClass); + G__get_linked_tagnum(&G__MuonCintLN_TBuffer); + G__get_linked_tagnum(&G__MuonCintLN_TMemberInspector); + G__get_linked_tagnum(&G__MuonCintLN_TObject); + G__get_linked_tagnum(&G__MuonCintLN_MParContainer); + G__get_linked_tagnum(&G__MuonCintLN_TH1F); + G__get_linked_tagnum(&G__MuonCintLN_MHillas); + G__get_linked_tagnum(&G__MuonCintLN_MGeomCam); + G__get_linked_tagnum(&G__MuonCintLN_MCerPhotEvt); + G__tagtable_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonSearchPar),sizeof(MMuonSearchPar),-1,323840,"Container to hold muon search parameters",G__setup_memvarMMuonSearchPar,G__setup_memfuncMMuonSearchPar); + G__tagtable_setup(G__get_linked_tagnum(&G__MuonCintLN_MMuonCalibPar),sizeof(MMuonCalibPar),-1,323840,"Container to hold muon calibration parameters",G__setup_memvarMMuonCalibPar,G__setup_memfuncMMuonCalibPar); +} +extern "C" void G__cpp_setupMuonCint(void) { + G__check_setup_version(30051515,"G__cpp_setupMuonCint()"); + G__set_cpp_environmentMuonCint(); + G__cpp_setup_tagtableMuonCint(); + + G__cpp_setup_inheritanceMuonCint(); + + G__cpp_setup_typetableMuonCint(); + + G__cpp_setup_memvarMuonCint(); + + G__cpp_setup_memfuncMuonCint(); + G__cpp_setup_globalMuonCint(); + G__cpp_setup_funcMuonCint(); + + if(0==G__getsizep2memfunc()) G__get_sizep2memfuncMuonCint(); + return; +} +class G__cpp_setup_initMuonCint { + public: + G__cpp_setup_initMuonCint() { G__add_setup_func("MuonCint",(G__incsetup)(&G__cpp_setupMuonCint)); G__call_setup_funcs(); } + ~G__cpp_setup_initMuonCint() { G__remove_setup_func("MuonCint"); } +}; +G__cpp_setup_initMuonCint G__cpp_setup_initializerMuonCint; + Index: trunk/MagicSoft/Mars/mmuon/MuonCint.h =================================================================== --- trunk/MagicSoft/Mars/mmuon/MuonCint.h (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MuonCint.h (revision 5173) @@ -0,0 +1,48 @@ +/******************************************************************** +* MuonCint.h +********************************************************************/ +#ifdef __CINT__ +#error MuonCint.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#include "G__ci.h" +extern "C" { +extern void G__cpp_setup_tagtableMuonCint(); +extern void G__cpp_setup_inheritanceMuonCint(); +extern void G__cpp_setup_typetableMuonCint(); +extern void G__cpp_setup_memvarMuonCint(); +extern void G__cpp_setup_globalMuonCint(); +extern void G__cpp_setup_memfuncMuonCint(); +extern void G__cpp_setup_funcMuonCint(); +extern void G__set_cpp_environmentMuonCint(); +} + + +#include "TROOT.h" +#include "TMemberInspector.h" +#include "MMuonSearchPar.h" +#include "MMuonCalibPar.h" +#include "MuonIncl.h" + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__MuonCintLN_TClass; +extern G__linked_taginfo G__MuonCintLN_TBuffer; +extern G__linked_taginfo G__MuonCintLN_TMemberInspector; +extern G__linked_taginfo G__MuonCintLN_TObject; +extern G__linked_taginfo G__MuonCintLN_MParContainer; +extern G__linked_taginfo G__MuonCintLN_TH1F; +extern G__linked_taginfo G__MuonCintLN_MHillas; +extern G__linked_taginfo G__MuonCintLN_MGeomCam; +extern G__linked_taginfo G__MuonCintLN_MCerPhotEvt; +extern G__linked_taginfo G__MuonCintLN_MMuonSearchPar; +extern G__linked_taginfo G__MuonCintLN_MMuonCalibPar; + +/* STUB derived class for protected member access */ Index: trunk/MagicSoft/Mars/mmuon/MuonIncl.h =================================================================== --- trunk/MagicSoft/Mars/mmuon/MuonIncl.h (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MuonIncl.h (revision 5173) @@ -0,0 +1,3 @@ +#ifndef __CINT__ + +#endif // __CINT__ Index: trunk/MagicSoft/Mars/mmuon/MuonLinkDef.h =================================================================== --- trunk/MagicSoft/Mars/mmuon/MuonLinkDef.h (revision 5173) +++ trunk/MagicSoft/Mars/mmuon/MuonLinkDef.h (revision 5173) @@ -0,0 +1,17 @@ +#ifdef __CINT__ + +#pragma link off all globals; +#pragma link off all classes; +#pragma link off all functions; + +#pragma link C++ class MMuonSearchPar+; +#pragma link C++ class MMuonCalibPar+; + +#endif + + + + + + +