Changeset 1629 for trunk


Ignore:
Timestamp:
11/18/02 10:46:48 (22 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/Changelog

    r1628 r1629  
    11                                                                  -*-*- END -*-*-
     2
     3 2002/11/18: Thomas Bretz
     4
     5   * macros/multidimdist2.C:
     6     - fixed a typo
     7     - added Alpha and Theta
     8
     9   * mbase/MTime.h:
     10     - added minus-operator
     11
     12   * mdata/MDataChain.[h,cc]:
     13     - added floor
     14
     15   * mhist/MFillH.[h,cc]:
     16     - moved MMap and MMap support MHArray
     17
     18   * mhist/MHArray.[h,cc]:
     19     - added MMap
     20     - added MMap-support
     21     - added legend
     22     - added more draw options
     23
     24   * mhist/MHFadcCam.[h,cc]:
     25     - added Fill(const MRawEvtData*)
     26     - added const getter functions
     27
     28   * mhist/MHFadcPix.h:
     29     - added const getter functions
     30
     31   * mmc/MMcCorsikaRunHeader.[h,cc]:
     32     - removed underscores from names
     33     - removed empty destructor
     34
     35
     36
    237 2002/11/16: Abelardo Moralejo
    338
    439   * mmc/MMcCorsikaRunHeader.cc:
    540     - added default destructor
     41
     42
    643
    744 2002/11/15: Thomas Bretz

  • trunk/MagicSoft/Mars/macros/multidimdist2.C

    r1608 r1629  
    6565    //  Give the names of the star-files to be read
    6666    //   Here you give the trainings sample(s) for
    67     //                 the hadrons
     67    //                 the gammas
    6868    // ---------------------------------------------
    6969    MReadMarsFile readg("Events", "star_gammas.root");
    … …  
    8383    matrix.AddColumn("MHillasSrc.fDist");
    8484    matrix.AddColumn("log10(MHillas.fSize)");
     85    matrix.AddColumn("MHillasSrc.fAlpha");
     86    matrix.AddColumn("MMcEvt.fTheta");
    8587    plist.AddToList(&matrix);
    8688

  • trunk/MagicSoft/Mars/mbase/MTime.h

    r1014 r1629  
    8686};
    8787
     88inline Double_t operator-(MTime &t1, MTime &t2)
     89{
     90    return (Double_t)t1.GetTimeLo()-(Double_t)t2.GetTimeLo();
     91}
     92
    8893inline Bool_t operator<(MTime &t1, MTime &t2)
    8994{

  • trunk/MagicSoft/Mars/mdata/MDataChain.cc

    r1574 r1629  
    7070//   sqrt(x)   square root of x
    7171//   abs(x)    absolute value of x, |x|
     72//   floor(x)  round down to the nearest integer (floor(9.9)=9)
    7273//
    7374//
    … …  
    227228    if (txt=="pow10") return kEPow10;
    228229    if (txt=="sgn")   return kESgn;
     230    if (txt=="floor") return kEFloor;
    229231    if (txt[0]=='-')  return kENegative;
    230232    if (txt[0]=='+')  return kEPositive;
    … …  
    471473    case kENegative: return -val;
    472474    case kEPositive: return val;
     475    case kEFloor:    return floor(val);
    473476    case kENoop:     return val;
    474477    }
    … …  
    553556    case kENegative: str += "-"    ; break;
    554557    case kEPositive: str += "+"    ; break;
     558    case kEFloor:    str += "floor"; break;
    555559    case kENoop:
    556560        break;

  • trunk/MagicSoft/Mars/mdata/MDataChain.h

    r1574 r1629  
    3838        kESgn,
    3939        kEPositive,
    40         kENegative
     40        kENegative,
     41        kEFloor
    4142    } OperatorType_t;
    4243

  • trunk/MagicSoft/Mars/mhist/MFillH.cc

    r1574 r1629  
    8585ClassImp(MFillH);
    8686
    87 //////////////////////////////////////////////////////////////////////////////
    88 //
    89 // MMap
    90 //
    91 // This class maps a key-value to a given value. In its simple versions it
    92 // maps a key to an index.
    93 //
    94 //////////////////////////////////////////////////////////////////////////////
    95 #include <TArrayI.h>
    96 
    97 class MMap
    98 {
    99 private:
    100     TArrayI fKeys;
    101     TArrayI fValues;
    102 
    103     Int_t K(Int_t i) const { return ((TArrayI)fKeys)[i]; }
    104     Int_t V(Int_t i) const { return ((TArrayI)fValues)[i]; }
    105 
    106 public:
    107     // --------------------------------------------------------------------------
    108     //
    109     // Get the value which corresponds to the given key-value
    110     //
    111     Int_t GetValue(Int_t key) const
    112     {
    113         const Int_t n = fKeys.GetSize();
    114         for (int i=0; i<n; i++)
    115         {
    116             if (K(i)==key)
    117                 return V(i);
    118         }
    119         return -1;
    120     }
    121 
    122     // --------------------------------------------------------------------------
    123     //
    124     // Adds a new pair key-value. While the key is the key to the value.
    125     // if the key already exists the pair is ignored.
    126     //
    127     void Add(Int_t key, Int_t value)
    128     {
    129         if (GetValue(key)>=0)
    130             return;
    131 
    132         const Int_t n = fKeys.GetSize();
    133 
    134         fKeys.Set(n+1);
    135         fValues.Set(n+1);
    136 
    137         fKeys[n] = key;
    138         fValues[n] = value;
    139     }
    140 
    141     // --------------------------------------------------------------------------
    142     //
    143     // Adds a new pair key-value. While the key is the key to the value.
    144     // In this case the value is an automatically sequential created index.
    145     // if the key already exists the pair is ignored.
    146     //
    147     Int_t Add(Int_t key)
    148     {
    149         const Int_t k = GetValue(key);
    150         if (k>=0)
    151             return k;
    152 
    153         const Int_t n = fKeys.GetSize();
    154 
    155         fKeys.Set(n+1);
    156         fValues.Set(n+1);
    157 
    158         fKeys[n] = key;
    159         fValues[n] = n;
    160 
    161         return n;
    162     }
    163 };
    164 
    16587// --------------------------------------------------------------------------
    16688//
    … …  
    17799
    178100    fIndex  = NULL;
    179     fMapIdx = new MMap;
    180101}
    181102
    … …  
    326247        if (fIndex->TestBit(kCanDelete))
    327248            delete fIndex;
    328 
    329     delete fMapIdx;
    330249}
    331250
    … …  
    500419{
    501420    if (fIndex)
    502     {
    503         const Int_t key = (Int_t)fIndex->GetValue();
    504         const Int_t idx = fMapIdx->Add(key);
    505         ((MHArray*)fH)->SetIndex(idx);
    506     }
     421        ((MHArray*)fH)->SetIndexByKey(fIndex->GetValue());
     422    /*
     423     const Int_t key = (Int_t)fIndex->GetValue();
     424     const Int_t idx = fMapIdx->Add(key);
     425     ((MHArray*)fH)->SetIndex(idx);
     426     */
    507427
    508428    return fH->Fill(fParContainer);

  • trunk/MagicSoft/Mars/mhist/MHArray.cc

    r1576 r1629  
    3737//  by its index.
    3838//
    39 //  To map a key to the index use/see MFillH, which automatically maps a
    40 //  key-value to the array index.
     39//  To access the histograms by a key instead of an index use SetIndexByKey
     40//  instead of Set/Inc/DecIndex. It will take the integerpart of the
     41//  floating point value (2 in case of 2.9). For each new key a new
     42//  index in the Mapping Table is created. So that you can access your
     43//  histograms by the key (eg in case of the Angle Theta=23.2deg use
     44//  SetIndexByKey(23.2)
     45//
     46//  If the index is equal to the number of histograms in the array a call
     47//  to the Fill-member-function will create a new histogram.
    4148//
    4249//  In the constructor istempl leads to two different behaviours of the
    … …  
    7380ClassImp(MHArray);
    7481
    75 // --------------------------------------------------------------------------
    76 //
    77 // Default Constructor. hname is the name of the histogram class which
    78 // is in the array.
     82//////////////////////////////////////////////////////////////////////////////
     83//
     84// MMap
     85//
     86// This class maps a key-value to a given value. In its simple versions it
     87// maps a key to an index.
     88//
     89//////////////////////////////////////////////////////////////////////////////
     90#include <TArrayI.h>
     91
     92class MMap
     93{
     94private:
     95    TArrayI fKeys;
     96    TArrayI fValues;
     97
     98    Int_t K(Int_t i) const { return ((TArrayI)fKeys)[i]; }
     99    Int_t V(Int_t i) const { return ((TArrayI)fValues)[i]; }
     100
     101public:
     102    // --------------------------------------------------------------------------
     103    //
     104    // Return the size of the table
     105    //
     106    Int_t GetSize() const
     107    {
     108        return fKeys.GetSize();
     109    }
     110
     111    // --------------------------------------------------------------------------
     112    //
     113    // Get the value which corresponds to the given key-value
     114    //
     115    Int_t GetValue(Int_t key) const
     116    {
     117        const Int_t n = fKeys.GetSize();
     118        for (int i=0; i<n; i++)
     119        {
     120            if (K(i)==key)
     121                return V(i);
     122        }
     123        return -1;
     124    }
     125
     126    // --------------------------------------------------------------------------
     127    //
     128    // Get the key which corresponds to the given index
     129    //
     130    Int_t GetKey(Int_t value) const
     131    {
     132        const Int_t n = fKeys.GetSize();
     133        for (int i=0; i<n; i++)
     134        {
     135            if (V(i)==value)
     136                return K(i);
     137        }
     138        return -1;
     139    }
     140
     141    // --------------------------------------------------------------------------
     142    //
     143    // Adds a new pair key-value. While the key is the key to the value.
     144    // if the key already exists the pair is ignored.
     145    //
     146    void Add(Int_t key, Int_t value)
     147    {
     148        if (GetValue(key)>=0)
     149            return;
     150
     151        const Int_t n = fKeys.GetSize();
     152
     153        fKeys.Set(n+1);
     154        fValues.Set(n+1);
     155
     156        fKeys[n] = key;
     157        fValues[n] = value;
     158    }
     159
     160    // --------------------------------------------------------------------------
     161    //
     162    // Adds a new pair key-value. While the key is the key to the value.
     163    // In this case the value is an automatically sequential created index.
     164    // if the key already exists the pair is ignored.
     165    //
     166    Int_t Add(Int_t key)
     167    {
     168        const Int_t k = GetValue(key);
     169        if (k>=0)
     170            return k;
     171
     172        const Int_t n = fKeys.GetSize();
     173
     174        fKeys.Set(n+1);
     175        fValues.Set(n+1);
     176
     177        fKeys[n] = key;
     178        fValues[n] = n;
     179
     180        return n;
     181    }
     182};
     183
     184// --------------------------------------------------------------------------
     185//
     186// hname is the name of the histogram class which is in the array.
    79187//
    80188// istempl=kTRUE tells MHArray to use the first histogram retrieved from the
    … …  
    95203    fTitle = title ? TString(title) : (TString("Base class for Mars histogram arrays:") + hname);
    96204
     205    fMapIdx = new MMap;
     206
    97207    fArray = new TList;
    98208    fArray->SetOwner();
    … …  
    131241// --------------------------------------------------------------------------
    132242//
     243// Default Constructor. hname is the name of the histogram class which
     244// is in the array.
     245//
     246// istempl=kTRUE tells MHArray to use the first histogram retrieved from the
     247// ParameterList by hname to be used as a template. New histograms are not
     248// created using the root dictionary, but the New-member function (see
     249// MParConatiner)
     250// In the case istempl=kFALSE new histograms are created using the root
     251// dictionary while hname is the class name. For the creation their
     252// default constructor is used.
     253//
     254MHArray::MHArray(const MH *hist, const char *name, const char *title)
     255    : fIdx(0), fClass(NULL), fTemplate(hist), fTemplateName("<dummy>")
     256{
     257    //
     258    //   set the name and title of this object
     259    //
     260    fName  = name  ? name  : "MHArray";
     261    fTitle = title ? TString(title) : (TString("Base class for Mars histogram arrays:") + hist->GetName());
     262
     263    fMapIdx = new MMap;
     264
     265    fArray = new TList;
     266    fArray->SetOwner();
     267}
     268
     269// --------------------------------------------------------------------------
     270//
    133271// Destructor: Deleteing the array and all histograms which are part of the
    134272// array.
    … …  
    138276    fArray->Delete();
    139277    delete fArray;
    140 }
    141 
    142 
     278    delete fMapIdx;
     279}
     280
     281// --------------------------------------------------------------------------
     282//
     283//  Use this to access the histograms by a key. If you use values like
     284//   (in this order) 2.5, 7.2, 2.5, 9.3, 9.3, 3.3, 2.2, 1.1
     285//  it will be mapped to the following indices internally:
     286//                    0    1    0    2    2    3    4    5
     287//
     288//  WARNING: Make sure that you don't create new histograms by setting
     289//           a new index (SetIndex or IncIndex) which is equal the size
     290//           of the array and create new histogram by CreateH. In this
     291//           case you will confuse the mapping completely.
     292//
     293void MHArray::SetIndexByKey(Double_t key)
     294{
     295    fIdx = fMapIdx->Add((Int_t)key);
     296}
     297
     298// --------------------------------------------------------------------------
     299//
     300//  Use this function to access a histogram by its index in the array.
     301//  Becarefull the index isn't checked!
     302//
    143303MH &MHArray::operator[](Int_t i)
    144304{
    … …  
    146306}
    147307
     308// --------------------------------------------------------------------------
     309//
     310//  Use this function to access a histogram by its index in the array.
     311//  Becarefull the index isn't checked!
     312//
    148313MH *MHArray::At(Int_t i)
    149314{
    … …  
    151316}
    152317
     318// --------------------------------------------------------------------------
     319//
     320//  Use this function to access the histogram corresponding to the
     321//  currently set index (by Set/Inc/DecIndex or SetIndexByKey)
     322//  Becarefull the index set isn't checked!
     323//
    153324MH *MHArray::GetH()
    154325{
    … …  
    170341    if (fTemplate)
    171342    {
     343        //
     344        // create the parameter container as a clone of the existing
     345        // template histogram.
     346        //
    172347        hist = (MH*)fTemplate->New();
    173348    }
    … …  
    226401    fIdx = 0;
    227402
     403    if (fTemplate)
     404        return kTRUE;
     405
    228406    if (!fTemplateName.IsNull())
    229407    {
    … …  
    246424    const Int_t n = fArray->GetSize();
    247425
    248     if (fIdx <0 || fIdx>n)
     426    if (fIdx<0 || fIdx>n)
    249427    {
    250428        *fLog << warn << "Histogram Index #" << fIdx << " out of bounds (>";
    … …  
    287465    *fLog << all << GetDescriptor() << " contains " << fArray->GetSize();
    288466    *fLog << " histograms." << endl;
    289 }
     467
     468    if (fMapIdx->GetSize()<=0)
     469        return;
     470
     471    *fLog << " idx\t     key" << endl;
     472    for (int i=0; i<fMapIdx->GetSize(); i++)
     473        *fLog << "  " << i << "\t<-->  " << fMapIdx->GetKey(i) << endl;
     474    *fLog << endl;
     475}
     476
     477// --------------------------------------------------------------------------
     478//
     479// Adds the given object to the given legend (if != NULL). The Legend
     480// entry name is created from the key...
     481//
     482void MHArray::AddLegendEntry(TLegend *leg, TObject *obj, Int_t idx) const
     483{
     484    if (!leg)
     485        return;
     486
     487    TString name = " ";
     488    name += fMapIdx->GetKey(idx);
     489    leg->AddEntry(obj, name, "lpf"); // l=line, p=polymarker, f=fill
     490}
     491
    290492
    291493// --------------------------------------------------------------------------
    … …  
    302504    gStyle->SetOptStat(0);
    303505
     506    //
     507    // if the keymapping is used create a legend to identify the histograms
     508    //
     509    TLegend *leg = NULL;
     510    if (fMapIdx->GetSize()>0)
     511    {
     512        leg = new TLegend(0.85, 0.80, 0.99, 0.99);
     513        leg->SetBit(kCanDelete);
     514    }
     515
    304516    TIter Next(fArray);
    305517    MH *hist = (MH*)Next();
    306518
    307     Int_t col=2;
     519    Int_t idx=0;
    308520    Double_t max=0;
    309521    Double_t min=0;
    … …  
    311523    TH1 *h1=NULL;
    312524
     525    //
     526    // If the array has at least one entry:
     527    //  - find the starting boundaries
     528    //  - draw it and set its line color
     529    //
    313530    if (hist)
    314531    {
    … …  
    316533        {
    317534            h1->Draw();
    318             h1->SetLineColor(col++);
     535            h1->SetLineColor(idx+2);
    319536            max = h1->GetMaximum();
    320537            min = h1->GetMinimum();
     538
     539            AddLegendEntry(leg, h1, idx);
    321540        }
    322541    }
    323542
     543    //
     544    // For all following histograms:
     545    //  - update the boundaries
     546    //  - draw it and set its line color
     547    //
    324548    while ((hist=(MH*)Next()))
    325549    {
    … …  
    330554
    331555        h->Draw("same");
    332         h->SetLineColor(col++);
     556        h->SetLineColor(idx+2);
    333557        if (max<h->GetMaximum())
    334558            max = h->GetMaximum();
    335559        if (min>h->GetMinimum())
    336560            min = h->GetMinimum();
    337     }
    338 
     561
     562        AddLegendEntry(leg, h, idx++);
     563    }
     564
     565    //
     566    // Now update the drawing region so that everything is displayed
     567    //
    339568    if (h1)
    340569    {
    … …  
    342571        h1->SetMaximum(max>0 ? max*1.05 : max*0.95);
    343572    }
     573
     574    if (leg)
     575        leg->Draw();
     576
    344577    gPad->Modified();
    345578    gPad->Update();
    … …  
    353586// the MH entries by calling their GetHistByName function.
    354587// If the option also contains 'nonew' no new canvas is created.
     588// The option "Scale=1" scales the area of all histogram to 1
     589// The option "Scale=max" scales the maximum of all histogram to 1
    355590//
    356591TObject *MHArray::DrawClone(Option_t *opt) const
    … …  
    360595    TCanvas *c = NULL;
    361596
    362     Int_t nonew = o.Index("nonew", TString::kIgnoreCase);
     597    Int_t scale1   = o.Index("scale=1",   TString::kIgnoreCase);
     598    Int_t scalemax = o.Index("scale=max", TString::kIgnoreCase);
     599    Int_t nonew    = o.Index("nonew",     TString::kIgnoreCase);
     600
     601    if (o.BeginsWith("scale=1", TString::kIgnoreCase))
     602        scale1 = 0;
     603    if (o.BeginsWith("scale=max", TString::kIgnoreCase))
     604        scalemax = 0;
     605    if (o.BeginsWith("nonew", TString::kIgnoreCase))
     606        nonew = 0;
     607
    363608    if (nonew>=0)
    364609    {
    … …  
    372617        o.Remove(nonew, 5);
    373618    }
     619    if (scale1>=0)
     620        o.Remove(scale1, 7);
     621    if (scalemax>=0)
     622        o.Remove(scalemax, 9);
    374623
    375624    const Stat_t sstyle = gStyle->GetOptStat();
    376625    gStyle->SetOptStat(0);
    377626
     627    //
     628    // if the keymapping is used create a legend to identify the histograms
     629    //
     630    TLegend *leg = NULL;
     631    if (fMapIdx->GetSize()>0)
     632    {
     633        leg = new TLegend(0.85, 0.80, 0.99, 0.99);
     634        leg->SetBit(kCanDelete);
     635    }
     636
    378637    TIter Next(fArray);
    379638    MH *hist = (MH*)Next();
    380639
    381     Int_t col=2;
     640    Int_t idx=0;
    382641    Double_t max=0;
    383642    Double_t min=0;
    … …  
    385644    TH1 *h1=NULL;
    386645
     646     //
     647    // If the array has at least one entry:
     648    //  - find the starting boundaries
     649    //  - draw it and set its line color
     650    //
    387651    if (hist)
    388652    {
    … …  
    390654        {
    391655            h1 = (TH1*)h1->DrawCopy();
    392             h1->SetMarkerColor(col);
    393             h1->SetLineColor(col++);
     656
     657            if (scale1>=0)
     658                h1->Scale(1./h1->Integral());
     659            if (scalemax>=0)
     660                h1->Scale(1./h1->GetMaximum());
     661
     662            h1->SetMarkerColor(idx);
     663            h1->SetLineColor(idx+2);
    394664            h1->SetFillStyle(4000);
    395665            max = h1->GetMaximum();
    396666            min = h1->GetMinimum();
     667
     668            AddLegendEntry(leg, h1, idx++);
    397669        }
    398670    }
    399671
     672    //
     673    // For all following histograms:
     674    //  - update the boundaries
     675    //  - draw it and set its line color
     676    //
    400677    while ((hist=(MH*)Next()))
    401678    {
    … …  
    406683
    407684        h = (TH1*)h->DrawCopy("same");
    408         h->SetMarkerColor(col);
    409         h->SetLineColor(col++);
    410         h->SetFillStyle(4000);
     685
     686        if (scale1>=0)
     687            h->Scale(1./h->Integral());
     688        if (scalemax>=0)
     689            h->Scale(1./h->GetMaximum());
     690
     691        h->SetMarkerColor(idx);
     692        h->SetLineColor(idx+2);
     693        h->SetFillStyle(4000); // transperent (why is this necessary?)
    411694        if (max<h->GetMaximum())
    412695            max = h->GetMaximum();
    413696        if (min>h->GetMinimum())
    414697            min = h->GetMinimum();
    415     }
    416 
     698
     699        AddLegendEntry(leg, h, idx++);
     700    }
     701
     702    //
     703    // Now update the drawing region so that everything is displayed
     704    //
    417705    if (h1)
    418706    {
    … …  
    420708        h1->SetMaximum(max>0 ? max*1.05 : max*0.95);
    421709    }
     710
     711    if (leg)
     712        leg->Draw();
     713
    422714    gPad->Modified();
    423715    gPad->Update();

  • trunk/MagicSoft/Mars/mhist/MHArray.h

    r1574 r1629  
    77
    88class TList;
     9class TLegend;
     10
     11class MMap;
    912
    1013class MHArray : public MH
    … …  
    1518
    1619    const MParList *fParList; //! pointer to parameter list used for SetupFill when a new Hist is created
    17     TClass *fClass;           //! pointer to class entry in root dictionary
     20    TClass *fClass;           // pointer to class entry in root dictionary
    1821
    19     MH *fTemplate;            //! pointer to a template histogram
    20     TString fTemplateName;    //! name of the template class
     22    const MH *fTemplate;      //-> pointer to a template histogram
     23    TString fTemplateName;    // name of the template class
     24
     25    MMap *fMapIdx;            //! Table to map keys to array indices
    2126
    2227    Bool_t CreateH();
     28    void   AddLegendEntry(TLegend *leg, TObject *obj, Int_t idx) const;
    2329
    2430    enum { kUseTemplate=BIT(14) };
    … …  
    2632public:
    2733    MHArray(const TString hname, Bool_t istempl=kFALSE, const char *name=NULL, const char *title=NULL);
     34    MHArray(const MH *hist, const char *name=NULL, const char *title=NULL);
    2835    ~MHArray();
    2936
    … …  
    3643
    3744    MH *GetH();
     45
     46    void SetIndexByKey(Double_t key);
    3847
    3948    void SetIndex(Int_t i) { fIdx=i; }

  • trunk/MagicSoft/Mars/mhist/MHFadcCam.cc

    r1600 r1629  
    100100        const UInt_t id = pixel.GetPixelId();
    101101
    102         for (Int_t i=0;  i<nhisamples; i++)
     102        for (Int_t i=0; i<nhisamples; i++)
    103103            FillHi(id, pixel.GetHiGainSamples()[i]);
    104104
    … …  
    113113}
    114114
     115Bool_t MHFadcCam::Fill(const MRawEvtData *par)
     116{
     117    return Fill((MParContainer*)par);
     118}
     119
    115120void MHFadcCam::ResetHistograms()
    116121{

  • trunk/MagicSoft/Mars/mhist/MHFadcCam.h

    r1600 r1629  
    1717#endif
    1818
     19class MRawEvtData;
     20
    1921class MHFadcCam : public MH
    2022{
    … …  
    3032
    3133    MHFadcPix *operator[](UInt_t i) { return (MHFadcPix*)(fArray->At(i)); }
     34    const MHFadcPix *operator[](UInt_t i) const { return (MHFadcPix*)(fArray->At(i)); }
    3235
    3336    TH1F *GetHistHi(UInt_t i)  { return (*this)[i]->GetHistHi(); }
    3437    TH1F *GetHistLo(UInt_t i)  { return (*this)[i]->GetHistLo(); }
    3538
     39    const TH1F *GetHistHi(UInt_t i) const { return (*this)[i]->GetHistHi(); }
     40    const TH1F *GetHistLo(UInt_t i) const { return (*this)[i]->GetHistLo(); }
     41
    3642    Bool_t Fill(const MParContainer *par);
     43    Bool_t Fill(const MRawEvtData *par);
    3744
    3845    void ResetHistograms();

  • trunk/MagicSoft/Mars/mhist/MHFadcPix.h

    r1303 r1629  
    2323    TH1F *GetHistLo() { return fHistLo; }
    2424
     25    const TH1F *GetHistHi() const { return fHistHi; }
     26    const TH1F *GetHistLo() const { return fHistLo; }
     27
    2528    void FillHi(Byte_t i);
    2629    void FillLo(Byte_t i);

  • trunk/MagicSoft/include-Classes/MMcFormat/MMcCorsikaRunHeader.cc

    r1628 r1629  
    4747    fTitle = title ? title : "Translation of the CORSIKA header";
    4848
    49     fRunNumber = 0.0;
    50     fDate = 0.0;
    51     fCorsika_version = 0.0;
    52     fNumObsLev = 0.0;
    53     for(int i=0;i<10;i++)
    54         fHeightLev[i]=0.0;
    55     fSlopeSpec = 0.0;
    56     fELowLim = 0.0;
    57     fEUppLim = 0.0;
    58     fEGS4_flag = 0.0;
    59     fNKG_flag = 0.0;
    60     fEcutoffh = 0.0;
    61     fEcutoffm = 0.0;
    62     fEcutoffe = 0.0;
    63     fEcutoffg = 0.0;
     49    fRunNumber = 0;
     50    fDate = 0;
     51    fCorsikaVersion = 0;
     52    fNumObsLev = 0;
    6453
    65     for(int i=0;i<50;i++)  fC[i] = 0.0;
    66     for(int i=0;i<40;i++)  fCKA[i] = 0.0;
    67     for(int i=0;i<5 ;i++)  fCETA[i] = 0.0;
    68     for(int i=0;i<11;i++)  fCSTRBA[i] = 0.0;
    69     for(int i=0;i<5;i++){
    70         fAATM[i] = 0.0;
    71         fBATM[i] = 0.0;
    72         fCATM[i] = 0.0;
     54    for (int i=0; i<10; i++)
     55        fHeightLev[i]=0;
     56
     57    fSlopeSpec = 0;
     58    fELowLim = 0;
     59    fEUppLim = 0;
     60    fEGS4flag = 0;
     61    fNKGflag = 0;
     62    fEcutoffh = 0;
     63    fEcutoffm = 0;
     64    fEcutoffe = 0;
     65    fEcutoffg = 0;
     66
     67    for(int i=0; i<50; i++)  fC[i] = 0;
     68    for(int i=0; i<40; i++)  fCKA[i] = 0;
     69    for(int i=0; i<5; i++)  fCETA[i] = 0;
     70    for(int i=0; i<11; i++)  fCSTRBA[i] = 0;
     71    for(int i=0; i<5; i++)
     72    {
     73        fAATM[i] = 0;
     74        fBATM[i] = 0;
     75        fCATM[i] = 0;
    7376    }
    74     for(int i=0;i<4;i++)  fNFL[i] = 0.0;
     77    for (int i=0;i<4; i++)  fNFL[i] = 0;
    7578
    7679}
    … …  
    105108    fRunNumber = runnumber;
    106109    fDate = date;
    107     fCorsika_version = vers;
     110    fCorsikaVersion = vers;
    108111    fNumObsLev = numobslev;
    109     for(int i=0;i<10;i++)
     112
     113    for (int i=0; i<10; i++)
    110114        fHeightLev[i]=height[i];
     115
    111116    fSlopeSpec = slope;
    112117    fELowLim = elow;
    113118    fEUppLim = eupp;
    114     fEGS4_flag = egs4;
    115     fNKG_flag = nkg;
     119    fEGS4flag = egs4;
     120    fNKGflag = nkg;
    116121    fEcutoffh = eh;
    117122    fEcutoffm = em;
    … …  
    119124    fEcutoffg = eg;
    120125
    121     for(int i=0;i<50;i++)  fC[i] = c[i];
    122     for(int i=0;i<40;i++)  fCKA[i] = cka[i];
    123     for(int i=0;i<5 ;i++)  fCETA[i] = ceta[i];
    124     for(int i=0;i<11;i++)  fCSTRBA[i] = cstrba[i];
    125     for(int i=0;i<5;i++){
     126    for (int i=0; i<50; i++)  fC[i] = c[i];
     127    for (int i=0; i<40; i++)  fCKA[i] = cka[i];
     128    for (int i=0; i<5 ; i++)  fCETA[i] = ceta[i];
     129    for (int i=0; i<11; i++)  fCSTRBA[i] = cstrba[i];
     130    for (int i=0; i<5; i++)
     131    {
    126132        fAATM[i] = aatm[i];
    127133        fBATM[i] = batm[i];
    128134        fCATM[i] = catm[i];
    129        }
    130     for(int i=0;i<4;i++)  fNFL[i] = nfl[i];
     135    }
     136    for (int i=0; i<4; i++)  fNFL[i] = nfl[i];
    131137}
    132138

  • trunk/MagicSoft/include-Classes/MMcFormat/MMcCorsikaRunHeader.h

    r1623 r1629  
    2020    Float_t fRunNumber;
    2121    Float_t fDate;
    22     Float_t fCorsika_version;
     22    Float_t fCorsikaVersion;
    2323    Float_t fNumObsLev;
    2424    Float_t fHeightLev[10];
    … …  
    2626    Float_t fELowLim;
    2727    Float_t fEUppLim;    // Limits of energy range for generation
    28     Float_t fEGS4_flag;
    29     Float_t fNKG_flag;
     28    Float_t fEGS4flag;
     29    Float_t fNKGflag;
    3030    Float_t fEcutoffh;
    3131    Float_t fEcutoffm;
    … …  
    4545public:
    4646    MMcCorsikaRunHeader(const char *name=NULL, const char *title=NULL);
    47     ~MMcCorsikaRunHeader();
    4847
    4948    void Fill(const Float_t  runnumber,
Note: See TracChangeset for help on using the changeset viewer.