Hi Ulrich,
Your classes seem to be OK. This is a simple case.
Probably you have something wrong in the classes implementation and
your main program.
I need access to these files to come with a diagnostic.
Rene Brun
Ulrich Husemann wrote:
>
> Dear Rooters!
>
> I adopted your Event class for my own purposes. While building a tree to
> fill in objects of the Event class ROOT crashes with a segmentation
> violation. Are there any restrictions to this class? The header looks like
> this:
>
> #include "TObject.h"
> #include "TClonesArray.h"
> #include <cmath>
> #include <iostream>
>
> class TDirectory;
>
> //****************************************************************************
> class EventHeader : public TObject
> {
> // Event Header class
>
> public:
> EventHeader();
> virtual ~EventHeader();
> Int_t GetEvtNum() const;
> Int_t GetRunNum() const;
> Int_t GetDate() const;
> Int_t GetTime() const;
> Int_t GetBX() const;
>
> void SetEvtNum(Int_t EvtNum);
> void SetRunNum(Int_t RunNum);
> void SetDate(Int_t Date);
> void SetTime(Int_t Time);
> void SetBX(Int_t BX);
> void SetAll(Int_t EvtNum, Int_t RunNum, Int_t Date, Int_t Time, Int_t
> BX);
>
> private:
> Int_t fEvtNum;
> Int_t fRunNum;
> Int_t fDate;
> Int_t fTime;
> Int_t fBX;
>
> ClassDef(EventHeader,1)
> };
>
> inline Int_t EventHeader::GetEvtNum() const {return fEvtNum;}
> inline Int_t EventHeader::GetRunNum() const {return fRunNum;}
> inline Int_t EventHeader::GetDate() const {return fDate;}
> inline Int_t EventHeader::GetTime() const {return fTime;}
> inline Int_t EventHeader::GetBX() const {return fBX;}
> inline void EventHeader::SetEvtNum(Int_t EvtNum) {fEvtNum = EvtNum;}
> inline void EventHeader::SetRunNum(Int_t RunNum) {fRunNum = RunNum;}
> inline void EventHeader::SetDate(Int_t Date) {fDate = Date;}
> inline void EventHeader::SetTime(Int_t Time) {fTime = Time;}
> inline void EventHeader::SetBX(Int_t BX) {fBX = BX;}
>
> //****************************************************************************
>
> class Mimp : public TObject
> {
> public:
> Mimp(Float_t x = 0, Float_t y =0, Float_t z = 0, Float_t px = 0, Float_t
> py = 0,
> Float_t pz = 0, Int_t cmp = 0, Int_t nsl = 0)
> : fX(x), fY(y), fZ(z), fPx(px), fPy(py), fPz(pz), fCmp(cmp), fNsl(nsl)
> {}
> Mimp(Int_t cmp, Int_t nsl, Float_t x, Float_t y, Float_t z, Float_t tx,
> Float_t ty, Float_t p)
> : fX(x), fY(y), fZ(z), fCmp(cmp), fNsl(nsl)
> {
> SetConvertedMomenta(tx,ty,p);
> }
> Mimp(const Mimp* mymimp)
> : fX(mymimp->GetX()), fY(mymimp->GetY()), fZ(mymimp->GetZ()),
> fPx(mymimp->GetPx()), fPy(mymimp->GetPy()), fPz(mymimp->GetPz()),
> fCmp(mymimp->GetCmp()), fNsl(mymimp->GetNsl()) { }
> virtual ~Mimp() { }
> void Clear();
> Float_t GetX() const;
> Float_t GetY() const;
> Float_t GetZ() const;
> Float_t GetPx() const;
> Float_t GetPy() const;
> Float_t GetPz() const;
> Float_t GetPt() const;
> Int_t GetCmp() const;
> Int_t GetNsl() const;
> void SetX(Float_t x);
> void SetY(Float_t y);
> void SetZ(Float_t z);
> void SetPx(Float_t px);
> void SetPy(Float_t py);
> void SetPz(Float_t pz);
> void SetCmp(Int_t cmp);
> void SetNsl(Int_t nsl);
> void SetConvertedMomenta(Float_t tx, Float_t ty, Float_t p);
>
> private:
> Float_t fX; // x coordinate of MIMP
> Float_t fY; // y coordinate of MIMP
> Float_t fZ; // z coordinate of MIMP
> Float_t fPx; // px of track
> Float_t fPy; // py of track
> Float_t fPz; // pz of track
> Int_t fCmp; // component where MIMP was found
> Int_t fNsl; // superlayer where MIMP was found
>
> ClassDef(Mimp,1)
> };
>
> inline Float_t Mimp::GetX() const {return fX;}
> inline Float_t Mimp::GetY() const {return fY;}
> inline Float_t Mimp::GetZ() const {return fZ;}
> inline Float_t Mimp::GetPx() const {return fPx;}
> inline Float_t Mimp::GetPy() const {return fPy;}
> inline Float_t Mimp::GetPz() const {return fPz;}
> inline Float_t Mimp::GetPt() const {return sqrt(fPx*fPx + fPy*fPy);}
> inline Int_t Mimp::GetCmp() const {return fCmp;}
> inline Int_t Mimp::GetNsl() const {return fNsl;}
> inline void Mimp::SetX(Float_t x){fX = x;}
> inline void Mimp::SetY(Float_t y){fY = y;}
> inline void Mimp::SetZ(Float_t z){fZ = z;}
> inline void Mimp::SetPx(Float_t px) {fPx = px;}
> inline void Mimp::SetPy(Float_t py) {fPy = py;}
> inline void Mimp::SetPz(Float_t pz) {fPz = pz;}
> inline void Mimp::SetCmp(Int_t cmp) {fCmp = cmp;}
> inline void Mimp::SetNsl(Int_t nsl) {fNsl = nsl;}
>
> //****************************************************************************
>
> class Event : public TObject
> {
> // Main event class
> public:
> Event();
> virtual ~Event();
> void Clear(Option_t *option = "");
> void Reset(Option_t *option = "");
>
> Int_t GetNb0sMimps() const;
> Int_t GetNmuplusMimps() const;
> Int_t GetNmuminusMimps() const;
> EventHeader* GetHeader();
> TClonesArray* GetB0sMimps() const;
> TClonesArray* GetMuplusMimps() const;
> TClonesArray* GetMuminusMimps() const;
>
> void SetNb0sMimps(Int_t n);
> void SetNmuplusMimps(Int_t n);
> void SetNmuminusMimps(Int_t n);
> void SetHeader(Int_t EvtNum, Int_t RunNum, Int_t Date, Int_t Time, Int_t
> BX);
>
> void AddB0sMimp(const Mimp*);
> void AddMuplusMimp(const Mimp*);
> void AddMuminusMimp(const Mimp*);
> void AddMimp(const Mimp*, char *particle);
>
> private:
> Int_t fNb0sMimps;
> Int_t fNmuplusMimps;
> Int_t fNmuminusMimps;
> EventHeader fEvtHdr;
> TClonesArray* fB0sMimps;
> TClonesArray* fMuplusMimps;
> TClonesArray* fMuminusMimps;
>
> static TClonesArray* fgB0sMimps;
> static TClonesArray* fgMuplusMimps;
> static TClonesArray* fgMuminusMimps;
>
> ClassDef(Event,1)
> };
>
> inline Int_t Event::GetNb0sMimps() const {return fNb0sMimps;}
> inline Int_t Event::GetNmuplusMimps() const {return fNmuplusMimps;}
> inline Int_t Event::GetNmuminusMimps() const {return fNmuminusMimps;}
> inline EventHeader* Event::GetHeader() {return &fEvtHdr;}
> inline TClonesArray* Event::GetB0sMimps() const {return fB0sMimps;}
> inline TClonesArray* Event::GetMuplusMimps() const {return fMuplusMimps;}
> inline TClonesArray* Event::GetMuminusMimps() const {return
> fMuminusMimps;}
>
> inline void Event::SetNb0sMimps(Int_t n) {fNb0sMimps = n;}
> inline void Event::SetNmuplusMimps(Int_t n) {fNmuplusMimps = n;}
> inline void Event::SetNmuminusMimps(Int_t n) {fNmuminusMimps = n;}
>
> #endif
>
> Ulrich Husemann
This archive was generated by hypermail 2b29 : Tue Jan 02 2001 - 11:50:19 MET