Changeset 2885


Ignore:
Timestamp:
01/22/04 16:27:10 (21 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r2884 r2885  
    66 2004/01/22: Thomas Bretz
    77
    8    * mcalib/MCalibrationCam.[h,cc]:
     8   * mcalib/MCalibrate.[h,cc], mcalib/MCalibrationCam.[h,cc],
     9     mcalib/MCalibrationBlindPix.[h,cc], mcalib/MCalibrationCalc.[h,cc],
     10     mcalib/MCalibrationPix.[h,cc], mcalib/MCalibrationPINDiode.[h,cc],
     11     mcalib/MCalibrationBlindPixel.[h,cc],
     12     mcalib/MHCalibrationPixel.[h,cc], mcalib/MMcCalibrationCalc.[h,cc],
     13     mcalib/MHCalibrationBlindPixel.[h,cc],
     14     mcalib/MHCalibrationPINDiode.[h,cc]:
    915     - cleaned up includes
    1016

  • trunk/MagicSoft/Mars/mcalib/MCalibrate.cc

    r2855 r2885  
    4141#include "MCalibrate.h"
    4242#include "MCalibrationConfig.h"
    43 
    44 #include <TMath.h>
    4543
    4644#include "MLog.h"

  • trunk/MagicSoft/Mars/mcalib/MCalibrate.h

    r2734 r2885  
    1010//                                                                         //
    1111/////////////////////////////////////////////////////////////////////////////
    12 #ifndef ROOT_TArrayF
    13 #include <TArrayF.h>
    14 #endif
    15 
    1612#ifndef MARS_MTask
    1713#include "MTask.h"

  • trunk/MagicSoft/Mars/mcalib/MCalibrationBlindPix.h

    r2852 r2885  
    22#define MARS_MCalibrationBlindPix
    33
    4 #ifndef MARS_MParContainer
    5 #include "MParContainer.h"
     4#ifndef MARS_MHCalibrationBlindPixel
     5#include "MHCalibrationBlindPixel.h"
    66#endif
    7 
    8 #include "MHCalibrationBlindPixel.h"
    97
    108class MCalibrationBlindPix : public MParContainer

  • trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.cc

    r2880 r2885  
    2424
    2525//////////////////////////////////////////////////////////////////////////////
    26 //                                                                          //
    27 //   MCalibrationCalc                                                       //
    28 //                                                                          //
    29 //   This is a task which calculates the number of photons from the FADC    //
    30 //   time slices. At the moment it integrates simply the FADC values.       //
    31 //                                                                          //
    32 //  Input Containers:                                                       //
    33 //   MRawEvtData                                                            //
    34 //                                                                          //
    35 //  Output Containers:                                                      //
    36 //   MCalibrationCam                                                        //
    37 //                                                                          //
    38 //                                                                          //
    39 //  The class MCalibrationCam hold one entry of type MCalibrationPix for    //
    40 //  every pixel. It is filled in the following way:                         //
    41 //  PreParocess: MalibrationCam::InitSize(577) is called which allocates    //
    42 //               memory in an TClonesArray of type MCalibrationPix and      //
    43 //               all pointers to NULL.                                      //
    44 //                                                                          //
    45 //  Process:     The NULL pointer is tested on every pixel via              //
    46 //               MalibrationCam::IsPixelUsed(npix).                         //
    47 //                                                                          //
    48 //               In case, IsPixelUsed returns NULL,                         //
    49 //               MalibrationCam::AddPixel(npix) is invoked which creates a  //
    50 //               new MCalibrationPix(npix) in the npix's entry              //
    51 //               of the TClonesArray.                                       //
    52 //                                                                          //
    53 //               Every MCalibrationPix holds a histogram class,             //
    54 //               MHCalibrationPixel which itself hold histograms of type:   //
    55 //               HCharge(npix) (distribution of summed FADC time slice entries)
    56 //               HTime(npix) (distribution of position of maximum)             
     26//
     27//   MCalibrationCalc
     28//
     29//   This is a task which calculates the number of photons from the FADC
     30//   time slices. At the moment it integrates simply the FADC values.
     31//
     32//
     33//  The class MCalibrationCam hold one entry of type MCalibrationPix for
     34//  every pixel. It is filled in the following way:
     35//  PreParocess: MalibrationCam::InitSize(577) is called which allocates
     36//               memory in an TClonesArray of type MCalibrationPix and
     37//               all pointers to NULL.
     38//
     39//  Process:     The NULL pointer is tested on every pixel via
     40//               MalibrationCam::IsPixelUsed(npix).
     41//
     42//               In case, IsPixelUsed returns NULL,
     43//               MalibrationCam::AddPixel(npix) is invoked which creates a
     44//               new MCalibrationPix(npix) in the npix's entry
     45//               of the TClonesArray.
     46//
     47//               Every MCalibrationPix holds a histogram class,
     48//               MHCalibrationPixel which itself hold histograms of type:
     49//               HCharge(npix) (distribution of summed FADC time slice
     50//               entries)
     51//               HTime(npix) (distribution of position of maximum)
    5752//               HChargevsN(npix) (distribution of charges vs. event number.
    58 //                                                                         
    59 // PostProcess:  All histograms HCharge(npix) are fitted to a Gaussian     
    60 //               All histograms HTime(npix) are fitted to a Gaussian       
    61 //               The histogram HBlindPixelCharge (blind pixel) is fitted to a single     
    62 //                   PhE fit                                               
    63 //               The histogram HBlindPixelTime (blind pixel) is fitted to a Gaussian   
    64 //               The histograms of the PIN Diode are fitted to Gaussians   
    65 //                                                                         
    66 //               Fits can be excluded via the commands:                     
    67 //               MalibrationCam::SetSkipTimeFits()   (skip all time fits)   
    68 //               MalibrationCam::SetSkipBlindPixelFits()  (skip all blind pixel fits)
    69 //               MalibrationCam::SetSkipPinDiodeFits()  (skip all PIN Diode fits)
    70 //                                                                         
     53//
     54// PostProcess:  All histograms HCharge(npix) are fitted to a Gaussian
     55//               All histograms HTime(npix) are fitted to a Gaussian
     56//               The histogram HBlindPixelCharge (blind pixel) is fitted to
     57//               a single
     58//                   PhE fit
     59//               The histogram HBlindPixelTime (blind pixel) is fitted to a
     60//               Gaussian
     61//               The histograms of the PIN Diode are fitted to Gaussians
     62//
     63//               Fits can be excluded via the commands:
     64//               MalibrationCam::SetSkipTimeFits()   (skip all time fits)
     65//               MalibrationCam::SetSkipBlindPixelFits()  (skip all blind
     66//               pixel fits)
     67//               MalibrationCam::SetSkipPinDiodeFits()  (skip all PIN Diode
     68//               fits)
     69//
     70//  Input Containers:
     71//   MRawEvtData
     72//
     73//  Output Containers:
     74//   MCalibrationCam
     75//
    7176//////////////////////////////////////////////////////////////////////////////
    7277#include "MCalibrationCalc.h"
     78
     79// FXIME: Usage of fstream is a preliminary workaround!
     80#include <fstream>
     81
     82// FXIME: This has to be removed!!!!
    7383#include "MCalibrationConfig.h"
     84
     85#include <TSystem.h>
     86
     87#include "MLog.h"
     88#include "MLogManip.h"
     89
     90#include "MParList.h"
     91
     92#include "MGeomCam.h"
     93#include "MRawRunHeader.h"
     94#include "MRawEvtPixelIter.h"
     95
     96#include "MPedestalCam.h"
     97#include "MPedestalPix.h"
    7498
    7599#include "MCalibrationCam.h"
    76100#include "MCalibrationPix.h"
     101
     102#include "MExtractedSignalCam.h"
     103#include "MExtractedSignalPix.h"
     104
    77105#include "MCalibrationBlindPix.h"
    78106#include "MCalibrationPINDiode.h"
    79107
    80 #include "MPedestalCam.h"
    81 #include "MPedestalPix.h"
    82 
    83 #include "MGeomCam.h"
    84 
    85 #include "MLog.h"
    86 #include "MLogManip.h"
    87 
    88 #include "MParList.h"
    89 #include "MH.h"
    90 
    91 #include "MRawRunHeader.h"
    92 #include "MRawEvtData.h"     
    93 #include "MRawEvtPixelIter.h"
    94 
    95 #include "MExtractedSignalCam.h"
    96 #include "MExtractedSignalPix.h"
    97 
    98 #include "MTime.h"
    99 #include "TMath.h"
    100 #include "TSystem.h"
    101 
    102 #include <fstream>
    103 
    104108ClassImp(MCalibrationCalc);
    105109
    106110using namespace std;
     111
    107112// --------------------------------------------------------------------------
    108113//
    … …  
    130135    SETBIT(fFlags, kUsePinDiodeFit);
    131136
     137}
     138
     139MCalibrationBlindPix *MCalibrationCalc::GetBlindPixel() const
     140{
     141    return fCalibrations->GetBlindPixel();
     142}
     143
     144MCalibrationPINDiode *MCalibrationCalc::GetPINDiode() const
     145{
     146    return fCalibrations->GetPINDiode();
    132147}
    133148
    … …  
    516531        }
    517532
    518       blindpixel.DrawClone();
     533      //blindpixel.DrawClone();
    519534    }
    520535  else
    … …  
    563578    }
    564579
    565  
    566580  if (TESTBIT(fFlags,kUseBlindPixelFit))
    567581    {

  • trunk/MagicSoft/Mars/mcalib/MCalibrationCalc.h

    r2852 r2885  
    11#ifndef MARS_MCalibrationCalc
    22#define MARS_MCalibrationCalc
    3 
    4 /////////////////////////////////////////////////////////////////////////////
    5 //                                                                         //
    6 // MCalibrationCalc                                                   //
    7 //                                                                         //
    8 // Integrates the time slices of the all pixels of a calibration event     //
    9 // and substract the pedestal value                                        //
    10 //                                                                         //
    11 /////////////////////////////////////////////////////////////////////////////
    123
    134#ifndef MARS_MTask
    … …  
    156#endif
    167
    17 #ifndef ROOT_TArrayI
    18 #include "TArrayI.h"
    19 #endif
    20 
    21 #ifndef MARS_MCalibrationCam
    22 #include "MCalibrationCam.h"
    23 #endif
    24 
    25 #include "TString.h"
    26 
    27 class MRawEvtData;
    28 class MRawRunHeader;
    29 
    308class MPedestalCam;
    319class MCalibrationCam;
    3210class MExtractedSignalCam;
    3311
     12class MCalibrationBlindPix;
     13class MCalibrationPINDiode;
     14
    3415class MTime;
     16class MRawEvtData;
     17class MRawRunHeader;
    3518
    3619class MCalibrationCalc : public MTask
    … …  
    9881
    9982  // Getters
    100   MCalibrationBlindPix *GetBlindPixel()   const   { return fCalibrations->GetBlindPixel();  }
    101   MCalibrationPINDiode *GetPINDiode()     const   { return fCalibrations->GetPINDiode();  } 
     83  MCalibrationBlindPix *GetBlindPixel() const;
     84  MCalibrationPINDiode *GetPINDiode() const;
    10285
    10386  // Exclude pixels from configuration file

  • trunk/MagicSoft/Mars/mcalib/MCalibrationCam.h

    r2884 r2885  
    1919 
    2020  Int_t fNumPixels;
    21   TClonesArray *fPixels;                      // Array of MCalibrationPix with fit results
     21  TClonesArray *fPixels;                      //-> Array of MCalibrationPix with fit results
    2222 
    23   MCalibrationBlindPix *fBlindPixel;          // Pointer to the Blind Pixel with fit results
    24   MCalibrationPINDiode *fPINDiode;            // Pointer to the PIN Diode with fit results   
     23  MCalibrationBlindPix *fBlindPixel;          //-> Pointer to the Blind Pixel with fit results
     24  MCalibrationPINDiode *fPINDiode;            //-> Pointer to the PIN Diode with fit results
    2525
    2626  Bool_t  fNumPhotInsidePlexiglassAvailable;  // TRUE: Blind Pixel could have been fitted well

  • trunk/MagicSoft/Mars/mcalib/MCalibrationPINDiode.h

    r2734 r2885  
    22#define MARS_MCalibrationPINDiode
    33
    4 #ifndef MARS_MParContainer
    5 #include "MParContainer.h"
     4#ifndef MARS_MHCalibrationPINDiode
     5#include "MHCalibrationPINDiode.h"
    66#endif
    7 
    8 #include "MHCalibrationPINDiode.h"
    97
    108class MCalibrationPINDiode : public MParContainer

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationBlindPixel.cc

    r2883 r2885  
    2424
    2525//////////////////////////////////////////////////////////////////////////////
    26 //                                                                          //
    27 //  MHCalibrationBlindPixel                                                 //
    28 //                                                                          //
    29 //  Performs all the Single Photo-Electron Fit to extract                   //
    30 //  the mean number of photons and to derive the light flux                 //
    31 //                                                                          //
    32 // The fit result is accepted under condition that:                         //
    33 // 1) the Probability is greater than gkProbLimit (default 0.001 == 99.7%)  //
    34 // 2) at least 100 events are in the single Photo-electron peak             //
    35 //                                                                          //
     26//
     27//  MHCalibrationBlindPixel
     28//
     29//  Performs all the Single Photo-Electron Fit to extract
     30//  the mean number of photons and to derive the light flux
     31//
     32// The fit result is accepted under condition that:
     33// 1) the Probability is greater than gkProbLimit (default 0.001 == 99.7%)
     34// 2) at least 100 events are in the single Photo-electron peak
     35//
    3636//////////////////////////////////////////////////////////////////////////////
    3737#include "MHCalibrationBlindPixel.h"
    … …  
    3939
    4040#include <TStyle.h>
    41 #include <TMath.h>
    42 #include <TPad.h>
    43 
    44 #include <TMinuit.h>
    45 #include <TFitter.h>
    46 
    47 #include <TF1.h>
    48 #include <TH2.h>
    4941#include <TCanvas.h>
    5042#include <TPaveText.h>
     43
     44#include <TF1.h>
     45#include <TH1.h>
    5146#include <TRandom.h>
    52 
    53 #include <TText.h>
    54 
    55 #include "MBinning.h"
    56 #include "MParList.h"
    5747
    5848#include "MLog.h"
    … …  
    6252
    6353using namespace std;
     54
    6455// --------------------------------------------------------------------------
    6556//
    … …  
    145136}
    146137
     138Bool_t MHCalibrationBlindPixel::FillBlindPixelCharge(Float_t q)
     139{
     140    return fHBlindPixelCharge->Fill(q) > -1;
     141}
     142
     143Bool_t MHCalibrationBlindPixel::FillBlindPixelTime(Int_t t)
     144{
     145    return fHBlindPixelTime->Fill(t) > -1;
     146}
     147
     148Bool_t MHCalibrationBlindPixel::FillBlindPixelChargevsN(Stat_t rq, Int_t t)
     149{
     150    return fHBlindPixelChargevsN->Fill(t,rq) > -1;
     151}
    147152
    148153

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationBlindPixel.h

    r2880 r2885  
    66#endif
    77
     8class TH1F;
     9class TH1I;
     10class TF1;
     11class TPaveText;
     12
     13/*
    814#ifndef MARS_MHCalibrationConfig
    915#include "MHCalibrationConfig.h"
    … …  
    2935#include "TPaveText.h"
    3036#endif
    31 
     37*/
    3238
    3339
    … …  
    8894  ~MHCalibrationBlindPixel();
    8995
    90   Bool_t FillBlindPixelCharge(Float_t q)             { return fHBlindPixelCharge->Fill(q) > -1;  } 
    91   Bool_t FillBlindPixelTime(Int_t t)                 { return fHBlindPixelTime->Fill(t) > -1;  }
    92   Bool_t FillBlindPixelChargevsN(Stat_t rq, Int_t t) { return fHBlindPixelChargevsN->Fill(t,rq) > -1;  } 
     96  Bool_t FillBlindPixelCharge(Float_t q);
     97  Bool_t FillBlindPixelTime(Int_t t);
     98  Bool_t FillBlindPixelChargevsN(Stat_t rq, Int_t t);
    9399 
    94100

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationPINDiode.cc

    r2857 r2885  
    2424
    2525//////////////////////////////////////////////////////////////////////////////
    26 //                                                                          //
    27 //  MHCalibrationPINDiode                                                 //
    28 //                                                                          //
    29 //  Performs all the necessary fits to extract the mean number of photons   //
    30 //              out of the derived light flux                               //
    31 //                                                                          //
     26//
     27//  MHCalibrationPINDiode
     28//
     29//  Performs all the necessary fits to extract the mean number of photons
     30//              out of the derived light flux
     31//
    3232//////////////////////////////////////////////////////////////////////////////
    3333#include "MHCalibrationPINDiode.h"
    3434#include "MHCalibrationConfig.h"
    3535
    36 #include <TStyle.h>
    37 #include <TMath.h>
    38 
    39 #include <TMinuit.h>
    40 #include <TFitter.h>
    41 
     36#include <TH1.h>
    4237#include <TF1.h>
    43 #include <TH2.h>
    44 #include <TCanvas.h>
    45 #include <TPaveText.h>
    46 #include <TRandom.h>
    47 
    48 #include "MBinning.h"
    49 #include "MParList.h"
    50 
    51 #include "MLog.h"
    52 #include "MLogManip.h"
    5338
    5439ClassImp(MHCalibrationPINDiode);
    5540
    5641using namespace std;
     42
    5743// --------------------------------------------------------------------------
    5844//
    … …  
    11399}
    114100
     101const Double_t MHCalibrationPINDiode::GetTime() const
     102{
     103    return fVarGausFit->GetParameter(2);
     104}
     105
     106const Double_t MHCalibrationPINDiode::GetErrTime() const
     107{
     108    return fVarGausFit->GetParameter(3);
     109}

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationPINDiode.h

    r2852 r2885  
    66#endif
    77
    8 #ifndef MARS_MH
    9 #include "MH.h"
    10 #endif
    11 
    12 #ifndef ROOT_TH1
    13 #include "TH1.h"
    14 #endif
    15 
    16 #ifndef ROOT_TH1F
    17 #include "TH1F.h"
    18 #endif
    19 
    20 #ifndef ROOT_TF1
    21 #include "TF1.h"
    22 #endif
     8class TH1I;
     9class TH1F;
     10class TF1;
    2311
    2412class MHCalibrationPINDiode : public MHCalibrationPixel
    … …  
    4230  ~MHCalibrationPINDiode();
    4331
    44   const Double_t GetTime()      const { return fVarGausFit->GetParameter(2); }
    45   const Double_t GetErrTime()    const { return fVarGausFit->GetParameter(3); }
     32  const Double_t GetTime() const;
     33  const Double_t GetErrTime() const;
    4634
    4735  ClassDef(MHCalibrationPINDiode, 0)  // Histograms from the Calibration PIN Diode

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.cc

    r2852 r2885  
    2424
    2525//////////////////////////////////////////////////////////////////////////////
    26 //                                                                          //
    27 //  MHCalibrationPixel                                                 //
    28 //                                                                          //
    29 //  Performs all the necessary fits to extract the mean number of photons   //
    30 //              out of the derived light flux                               //
    31 //                                                                          //
     26//
     27//  MHCalibrationPixel
     28//
     29//  Performs all the necessary fits to extract the mean number of photons
     30//              out of the derived light flux
     31//
    3232//////////////////////////////////////////////////////////////////////////////
    3333#include "MHCalibrationPixel.h"
    3434#include "MHCalibrationConfig.h"
    3535
     36#include <TH1.h>
     37#include <TF1.h>
     38#include <TProfile.h>
     39
    3640#include <TStyle.h>
    37 #include <TMath.h>
    38 
    39 #include <TFitter.h>
    40 #include <TGraph.h>
    41 #include <TAxis.h>
    42 
    43 #include <TF1.h>
    44 #include <TH2.h>
    45 #include <TProfile.h>
    4641#include <TCanvas.h>
    47 #include <TPad.h>
    4842#include <TPaveText.h>
    49 
    50 #include "MParList.h"
    5143
    5244#include "MLog.h"
    … …  
    181173}
    182174
     175const Double_t MHCalibrationPixel::GetArea() const
     176{
     177    return fChargeGausFit->GetParameter(0);
     178}
     179
     180const Double_t MHCalibrationPixel::GetAreaErr() const
     181{
     182    return fChargeGausFit->GetParError(0);
     183}
     184
     185Bool_t MHCalibrationPixel::IsEmpty()
     186{
     187    return !(fHChargeHiGain->GetEntries() || fHChargeLoGain->GetEntries());
     188}
     189 
     190Bool_t MHCalibrationPixel::FillChargeLoGain(Float_t q)
     191{
     192    return (fHChargeLoGain->Fill(q) > -1);
     193}
     194
     195Bool_t MHCalibrationPixel::FillTimeLoGain(Int_t t)
     196{
     197    return (fHTimeLoGain->Fill(t)   > -1);
     198}
     199
     200Bool_t MHCalibrationPixel::FillChargevsNLoGain(Float_t q, Int_t n)
     201{
     202    return (fHChargevsNLoGain->Fill(n,q) > -1);
     203}
     204
     205Bool_t MHCalibrationPixel::FillChargeHiGain(Float_t q)
     206{
     207    return (fHChargeHiGain->Fill(q)      > -1);
     208}
     209
     210Bool_t MHCalibrationPixel::FillTimeHiGain(Int_t t)
     211{
     212    return (fHTimeHiGain->Fill(t)        > -1);
     213}
     214
     215Bool_t MHCalibrationPixel::FillChargevsNHiGain(Float_t q, Int_t n)
     216{
     217    return (fHChargevsNHiGain->Fill(n,q) > -1);
     218}
    183219
    184220void MHCalibrationPixel::ChangeHistId(Int_t id)

  • trunk/MagicSoft/Mars/mcalib/MHCalibrationPixel.h

    r2852 r2885  
    11#ifndef MARS_MHCalibrationPixel
    22#define MARS_MHCalibrationPixel
    3 
    4 #ifndef ROOT_TH1
    5 #include "TH1.h"
    6 #endif
    7 
    8 #ifndef ROOT_TH1
    9 #include "TH1F.h"
    10 #endif
    113
    124#ifndef MARS_MH
    … …  
    146#endif
    157
    16 #ifndef ROOT_TF1
    17 #include "TF1.h"
    18 #endif
    19 
    20 #ifndef ROOT_TProfile
    21 #include "TProfile.h"
    22 #endif
    23 
    24 #ifndef ROOT_TArrayF
    25 #include "TArrayF.h"
    26 #endif
    27 
     8class TArrayF;
     9class TH1F;
     10class TH1I;
     11class TF1;
     12class TProfile;
    2813class TPaveText;
    29 class TMath;
    30 class MParList;
    3114
    3215class MHCalibrationPixel : public MH
    … …  
    122105  const Double_t GetChargeSigma()    const { return fChargeSigma;   }
    123106  const Double_t GetChargeSigmaErr() const { return fChargeSigmaErr; }
    124   const Double_t GetArea()           const { return fChargeGausFit->GetParameter(0); }
    125   const Double_t GetAreaErr()        const { return fChargeGausFit->GetParError(0);  }
     107  const Double_t GetArea()           const;
     108  const Double_t GetAreaErr()        const;
    126109
    127110  const Double_t GetChargeChiSquare() const { return fChargeChisquare; }
    … …  
    152135  Bool_t UseLoGain();
    153136
    154   Bool_t IsFitOK()                           {  return fFitOK;          }
    155   Bool_t IsEmpty()                           {  return !( (fHChargeHiGain->GetEntries())
    156                                                      || (fHChargeLoGain->GetEntries()) ); } 
     137  Bool_t IsFitOK() { return fFitOK; }
     138  Bool_t IsEmpty();
    157139 
    158140  // Fill histos
    159   Bool_t FillChargeLoGain(Float_t q)             { return (fHChargeLoGain->Fill(q) > -1); }
    160   Bool_t FillTimeLoGain(Int_t t)                 { return (fHTimeLoGain->Fill(t)   > -1); }
    161   Bool_t FillChargevsNLoGain(Float_t q, Int_t n) { return (fHChargevsNLoGain->Fill(n,q) > -1); }
     141  Bool_t FillChargeLoGain(Float_t q);
     142  Bool_t FillTimeLoGain(Int_t t);
     143  Bool_t FillChargevsNLoGain(Float_t q, Int_t n);
    162144
    163   Bool_t FillChargeHiGain(Float_t q)             { return (fHChargeHiGain->Fill(q)      > -1); }
    164   Bool_t FillTimeHiGain(Int_t t)                 { return (fHTimeHiGain->Fill(t)        > -1); }
    165   Bool_t FillChargevsNHiGain(Float_t q, Int_t n) { return (fHChargevsNHiGain->Fill(n,q) > -1); }
     145  Bool_t FillChargeHiGain(Float_t q);
     146  Bool_t FillTimeHiGain(Int_t t);
     147  Bool_t FillChargevsNHiGain(Float_t q, Int_t n);
    166148
    167149  // Fits

  • trunk/MagicSoft/Mars/mcalib/MMcCalibrationCalc.cc

    r2876 r2885  
    11/* ======================================================================== *\
    2    !
    3    ! *
    4    ! * This file is part of MARS, the MAGIC Analysis and Reconstruction
    5    ! * Software. It is distributed to you in the hope that it can be a useful
    6    ! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
    7    ! * It is distributed WITHOUT ANY WARRANTY.
    8    ! *
    9    ! * Permission to use, copy, modify and distribute this software and its
    10    ! * documentation for any purpose is hereby granted without fee,
    11    ! * provided that the above copyright notice appear in all copies and
    12    ! * that both that copyright notice and this permission notice appear
    13    ! * in supporting documentation. It is provided "as is" without express
    14    ! * or implied warranty.
    15    ! *
    16    !
    17    !
    18    !   Author(s): Abelardo Moralejo, 12/2003 <mailto:moralejo@pd.infn.it>
    19    !
    20    !   Copyright: MAGIC Software Development, 2000-2003
    21    !
    22    !
    23    \* ======================================================================== */
     2!
     3! *
     4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
     5! * Software. It is distributed to you in the hope that it can be a useful
     6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
     7! * It is distributed WITHOUT ANY WARRANTY.
     8! *
     9! * Permission to use, copy, modify and distribute this software and its
     10! * documentation for any purpose is hereby granted without fee,
     11! * provided that the above copyright notice appear in all copies and
     12! * that both that copyright notice and this permission notice appear
     13! * in supporting documentation. It is provided "as is" without express
     14! * or implied warranty.
     15! *
     16!
     17!
     18!   Author(s): Abelardo Moralejo, 12/2003 <mailto:moralejo@pd.infn.it>
     19!
     20!   Copyright: MAGIC Software Development, 2000-2003
     21!
     22!
     23\* ======================================================================== */
    2424
    2525/////////////////////////////////////////////////////////////////////////////
    … …  
    4040#include "MMcCalibrationCalc.h"
    4141
    42 #include "MParList.h"
     42#include <TH1.h>
    4343
    4444#include "MLog.h"
    4545#include "MLogManip.h"
    4646
     47#include "MParList.h"
     48
    4749#include "MCalibrationPix.h"
    4850#include "MCalibrationCam.h"
     51
    4952#include "MGeomCam.h"
    5053#include "MRawRunHeader.h"
    51 #include "MMcFadcHeader.hxx"
     54
    5255#include "MHillas.h"
    5356#include "MNewImagePar.h"
     57
    5458#include "MMcEvt.hxx"
     59#include "MMcFadcHeader.hxx"
    5560
    5661ClassImp(MMcCalibrationCalc);

  • trunk/MagicSoft/Mars/mcalib/MMcCalibrationCalc.h

    r2876 r2885  
    1313class MMcFadcHeader;
    1414
    15 #include <TH1.h>
     15class TH1F;
    1616
    1717class MMcCalibrationCalc : public MTask
    1818{
    1919private:
    20     Bool_t CheckRunType(MParList *pList) const;
    21     Int_t  PreProcess(MParList *pList);
    22     Int_t  Process();
    23     Int_t  PostProcess();
    24     Bool_t ReInit(MParList *pList);
    25 
    2620    MCalibrationCam     *fCalCam;
    2721    MGeomCam            *fGeom;
    … …  
    3630    TH1F*   fHistRatio;
    3731
     32    Bool_t CheckRunType(MParList *pList) const;
     33    Int_t  PreProcess(MParList *pList);
     34    Int_t  Process();
     35    Int_t  PostProcess();
     36    Bool_t ReInit(MParList *pList);
     37
    3838public:
    3939    MMcCalibrationCalc(const char *name=NULL, const char *title=NULL);
Note: See TracChangeset for help on using the changeset viewer.