source: trunk/MagicSoft/Mars/msim/MPhotonEvent.h@ 9238

#ifndef MARS_MPhotonEvent
#define MARS_MPhotonEvent

#ifndef MARS_MParContainer
#include "MParContainer.h"
#endif
/*
#ifndef MARS_MCamEvent
#include "MCamEvent.h"
#endif
*/
#ifndef ROOT_TClonesArray
#include <TClonesArray.h>
#endif

// gcc 3.2
//class ifstream;
#include <iosfwd>

/*
class TH1;
class TH2;
class TH3;
*/

class MPhotonData;
class MCorsikaRunHeader;

class MyClonesArray : public TClonesArray
{
public:
    TObject **FirstRef() { return fCont; }

    void FastRemove(Int_t idx1, Int_t idx2)
    {
        // Remove object at index idx.

        //if (!BoundsOk("RemoveAt", idx1)) return 0;
        //if (!BoundsOk("RemoveAt", idx2)) return 0;

        Long_t dtoronly = TObject::GetDtorOnly();

        idx1 -= fLowerBound;
        idx2 -= fLowerBound;

        for (TObject **obj=fCont+idx1; obj<=fCont+idx2; obj++)
        {
            if (!*obj)
                continue;

            if ((*obj)->TestBit(kNotDeleted)) {
                // Tell custom operator delete() not to delete space when
                // object fCont[i] is deleted. Only destructors are called
                // for this object.
                TObject::SetDtorOnly(*obj);
                delete *obj;
            }

            *obj = 0;
            // recalculate array size
        }
        TObject::SetDtorOnly((void*)dtoronly);

        if (idx1<=fLast && fLast<=idx2)
        {
            do {
                fLast--;
            } while (fLast >= 0 && fCont[fLast] == 0);
        }

        Changed();
    }
};

class MPhotonEvent : public MParContainer//, public MCamEvent
{
private:
    TClonesArray fData;

public:
    MPhotonEvent(const char *name=NULL, const char *title=NULL);

    //void Clear(Option_t * = NULL);
    void Print(Option_t * = NULL) const;

    const char *GetClassName() const;

    TClonesArray &GetArray() { return fData; }
    const TClonesArray &GetArray() const { return fData; }
    void Remove(TObject *o) { fData.Remove(o); }

    MPhotonData &Add(Int_t n);
    MPhotonData &Add();

    MPhotonData &operator[](UInt_t idx);
    const MPhotonData &operator[](UInt_t idx) const;

    Int_t Shrink(Int_t n)
    {
        // The number of object written by the streamer is defined by
        // GetEntriesFast(), i.e. this number must be shrinked to
        // the real array size. We use RemoveAt instead of ExpandCreate
        // because RemoveAt doesn't free memory. Thus in the next
        // iteration it can be reused and doesn't need to be reallocated.
        // Do not change this. It is optimized for execution speed
        //        for (int i=fData.GetSize()-1; i>=n; i--)
        //          fData.RemoveAt(i);
        static_cast<MyClonesArray&>(fData).FastRemove(n, fData.GetSize()-1);

        return fData.GetEntriesFast();
    }
/*
    void Expand(Int_t n)
    {
        for (int i=fData.GetSize(); i<n; i++)
            fData.New(i);
    }
 */
    Int_t ReadCorsikaEvt(istream &fin);
    Int_t ReadRflEvt(istream &fin);

    Int_t GetNumPhotons() const { return fData.GetEntriesFast(); }
/*
    void FillRad(TH1 &hist, Float_t scale=1) const;
    void FillRad(TH2 &hist, Double_t x, Float_t scale=1) const;
    void Fill(TH2 &hist, Float_t scale=1) const;
    void Fill(TH3 &hist, Double_t z, Float_t scale=1) const;
 */
    void Paint(Option_t *o="");

//    Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const;
//    void   DrawPixelContent(Int_t num) const;

    void Sort() { fData.Sort(); }

    ClassDef(MPhotonEvent, 1) //Container to store the raw Event Data
};

// FIXME: Should we merge this into MPhotonEvent?
class MPhotonStatistics : public MParContainer
{
private:
    Float_t fTimeFirst;
    Float_t fTimeLast;

//    Float_t fOffset;
//    Float_t fWindow;

    Int_t fMaxIndex;

public:
    MPhotonStatistics(const char *name=NULL, const char *title=NULL) : fMaxIndex(-1)
    {
        fName  = name  ? name  : "MPhotonStatistics";
        fTitle = title ? title : "Corsika Event Data Information";
    }

    void SetTime(Float_t first, Float_t last) { fTimeFirst=first; fTimeLast=last; }
    void SetMaxIndex(UInt_t idx) { fMaxIndex=idx; }

//    Float_t GetRawTimeFirst() const { return fTimeFirst; }
//    Float_t GetRawTimeLast() const { return fTimeLast; }

    Float_t GetTimeFirst() const { return fTimeFirst; }
    Float_t GetTimeLast() const { return fTimeLast; }

    Int_t GetMaxIndex() const { return fMaxIndex; }

    Bool_t IsValid() const { return fTimeLast>=fTimeFirst; }

    ClassDef(MPhotonStatistics, 1)
};
#endif