TBranch crash

Piergiorgio Cerello (cerello@to.infn.it)
Thu, 23 Jul 1998 14:22:09 +0200 (MET DST)


Hi rooters,

I have a problem when trying to create a TBranch object.
The program crashes, giving a "segmentation violation".

I deeply investigated my code concerning the classes involved (TFndHdt,
TFndTrig), and I couldn't find the reason.

I have an object of class TFndHdt, which is composed by some integers and
a set of pointers (to objects of TFndTrig, TFndCorbo, TFndHHdr classes and
to 4 TObjArray objects).
I would like to store it in a Tree (and then on file), associating one
branch to each of the objects.

I tried both with the splitlevel = 1 option and with the detailed
declaration of all the branches.

The code compiles, but then it crashes when I try to define the branch
corresponding to the TFndTrig object, giving a segmentation violation.

In the following, you'll find the main program (with only the mentioned
branch definition) and the source code for the class TFndTrig.

I'm running under OSF, and the funny thing is that the same code, on
another OSF machine, runs correctly.

Any suggestion?

Thanks in advance,

Cheers,

Piergiorgio

// header file for TFndTrig

#ifndef FIN_FndTrig
#define FIN_FndTrig

//____________________________________________________________________
//
// TFndTrig
//
//

#include "TObject.h"
#include "TFndRawEqp.h"

class TFndTrig : public TObject {

private:

Int_t fTB; // Top-Bottom trigger
Int_t fTBCtfCtr; // Top-Bottom && (Central Front || Rear)
Int_t fCtf; // Central Front
Int_t fCtr; // Central Rear

public:
TFndTrig(TFndRawEqp *);
TFndTrig();
~TFndTrig();

Int_t GetTB() const { return fTB; } // Get TB trigger
Int_t GetTBCtfCtr() const { return fTBCtfCtr; } // TB && (F || R)
Int_t GetCtf() const { return fCtf; } // Central Front
Int_t GetCtr() const { return fCtr; } // Central Rear
void Print(); // Print the Trigger
variables

ClassDef(TFndTrig,1) // The Trigger
};

#endif

// source file for TFndTrig

#include "iostream.h"
#include "TFndRawEqp.h"
#include "TFndTrig.h"

ClassImp(TFndTrig);

TFndTrig::TFndTrig() {
fTB = -1;
fTBCtfCtr = -1;
fCtr = -1;
fCtf = -1;
}

TFndTrig::~TFndTrig() { }

TFndTrig::TFndTrig(TFndRawEqp *ptrg) {

// Trig equipment

UInt_t *ltrgptr = ptrg->GetEqp(21);
UInt_t ltrglen = ptrg->GetEqpLen(21);

if(ltrglen) {
fTB = (*ltrgptr)&0x1;
fTBCtfCtr = ((*ltrgptr)>>1)&0x1;
fCtr = ((*ltrgptr)>>4)&0x1;
fCtf = ((*ltrgptr)>>5)&0x1;
} else {
fTB = -1;
fTBCtfCtr = -1;
fCtr = -1;
fCtf = -1;
}
}

//******************************************************************/
//* Print Trigger */
//******************************************************************/

void TFndTrig::Print() {

cout << "**** Trigger ****" << endl;

cout << "Top*Bottom = " << fTB << endl;
cout << "Top*Bottom*(Central Front || Central Rear) = " << fTBCtfCtr <<
endl;
cout << "Central Front = " << fCtf << endl;
cout << "Central Rear = " << fCtr << endl;
}

// main program

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <iostream.h>

//******************************************************************/
//* ROOT include files */
//******************************************************************/

#include "TROOT.h"
#include "TFile.h"
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TNtuple.h"
#include "TRandom.h"
#include "TTree.h"
#include "TBranch.h"
#include "TObjArray.h"
#include "TDirectory.h"
#include "TServerSocket.h"
#include "TSocket.h"
#include "TMessage.h"
#include "TBuffer.h"

//******************************************************************/
//* FINUDA include files */
//******************************************************************/

#include "TFndFeeMap.h"
#include "TFndConst.h"
#include "TFndHHdr.h"
#include "TFndRawEqp.h"
#include "TFndRawSil.h"
#include "TFndRdt.h"
#include "TFndHdt.h"
#include "TFndHSil.h"
#include "TFndHTof.h"
#include "TFndHLmd.h"
#include "TFndHStb.h"
#include "TFndTrig.h"
#include "TFndCorbo.h"
#include "TFndDate.h"
#include "TFndGenInfo.h"

//******************************************************************/
//*-------> UNIX only */
//******************************************************************/

#include <fcntl.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/types.h>

#include <sys/socket.h>
#include <sys/un.h>

#include <netinet/in.h>
#include <netdb.h>

//******************************************************************/
//*-------> ZEBRA Common Block */
//******************************************************************/

#include "cfortran.h"
#include "TFndZebini.h"

ZEBINI_DEF Zebini;

#ifdef __SC__
long G__globalvarpointer;
#endif

TROOT geb2hdt("geb2hdt","FINUDA geb2hdt conversion");

//******************************************************************/
//* main */
//******************************************************************/

main(Int_t argc, Char_t **argv) {

//******************************************************************/
//* Read the mSQL database */
//******************************************************************/

// connect to mSQL database

char *host = argv[1];
cout << "mSQL host is " << host << endl;
TFndFeeMap *fndfeemap = new TFndFeeMap(host);
if(fndfeemap->IsThere()) fndfeemap->Print();

const Int_t EVHEAD=0x10;
const Int_t N_DET = 6;

// build up input file name

const char *fpth = argv[2];
const char *fgeb = "/geb/";
const char *fnam = argv[3];
const char *fonl = "onl";
const char *fraw = ".raw";

Int_t onlflg = 0;
cout << argv[3] << endl;
if(!strcmp(fnam,fonl)) onlflg = 1;
cout << "Online flag is " << onlflg << endl;

Int_t kSCALE = 1;
if(onlflg) kSCALE = 10;

Int_t ilen = strlen(fpth)+strlen(fgeb)+strlen(fnam)+strlen(fraw);
Char_t *ifn = new Char_t[ilen];
strcpy(ifn,fpth);
ifn = strcat(ifn,fgeb);
ifn = strcat(ifn,fnam);
ifn = strcat(ifn,fraw);

// open input file
FILE *f;
if(!onlflg) {
f = fopen(ifn,"rb");
if (f==NULL) {
cout << "file " << ifn << " does not exist" << endl;
exit(0);
}
}
// build up output file name

const char *frdt = "/HDT/";
const char *frot = ".hdt";
Int_t olen = strlen(fpth)+strlen(frdt)+strlen(fnam)+strlen(frot);
Char_t *ofn = new Char_t[olen];
strcpy(ofn,fpth);
ofn = strcat(ofn,frdt);
ofn = strcat(ofn,fnam);
ofn = strcat(ofn,frot);

// open connection with the Global Event Builder

Int_t fSockId = 0;
Int_t rawsize = 0;
Int_t ierr = 0;

if (onlflg) {

Int_t port_ev = 1242;
struct sockaddr_in myaddr;
bzero((char *) &myaddr, sizeof(struct sockaddr_in));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = INADDR_ANY;
myaddr.sin_port = htons(port_ev);
fSockId = socket(AF_INET, SOCK_DGRAM, 0);
cout << " fSockId = " << fSockId << endl;
if(fSockId == -1) {
ierr = -1;
cout << "ierr from FndRun(socket) is " << ierr << endl;
}
rawsize = 32000;
setsockopt(fSockId,SOL_SOCKET,SO_RCVBUF,(char *)
&rawsize,sizeof(rawsize));
ierr = bind(fSockId, (sockaddr *) &myaddr, sizeof(struct
sockaddr_in));
if(ierr == -1) {
ierr = -2;
cout << "ierr from FndRun(socket) is " << ierr << endl;
}

rawsize /= 4;
}
if(!onlflg) {
// read "event 0" header
UInt_t *raw = new UInt_t[EVHEAD];
if (fread(raw,sizeof(UInt_t), EVHEAD,f) !=EVHEAD) {
cout << "file " << ifn << " is shorter than event header" << endl;
exit(0);
}
rewind(f);

// swap "event 0" header if needed
for (Int_t j = 0; j< EVHEAD;j++ ) raw[j] = host2net(raw[j]);
delete [] raw;
}

// open output file

TFile *of = new TFile(ofn,"RECREATE","Finuda ROOT histograms");

// create RDT & HDT Trees

TTree *rdtt = new TTree("RawTree", "FINUDA raw event tree");
TTree *hdtt = new TTree("F","FINUDA HDT tree");
hdtt->SetAutoSave(10000000); // autosave when 10 Mbytes written
rdtt->SetAutoSave(10000000); // autosave when 10 Mbytes written

// create RDT & HDT

TFndRdt *fndrdt = new TFndRdt();
TFndHdt *fndhdt = new TFndHdt();

// create general run information
TFndGenInfo *g = new TFndGenInfo();

// RDT branches

TFndHHdr *hdr = 0;
TFndRawEqp *gts = 0;
TFndRawEqp *tof = 0;
TFndRawSil *ism = 0;
TFndRawSil *osm = 0;
TFndRawEqp *lmd = 0;
TFndRawEqp *stb = 0;

TBranch *Bhdr = rdtt->Branch("hdr","TFndHHdr",&hdr,64000,0);
TBranch *Bdet[N_DET];
Bdet[0] = rdtt->Branch("gts","TFndRawEqp",&gts,64000,0);
Bdet[1] = rdtt->Branch("tof","TFndRawEqp",&tof,64000,0);
Bdet[2] = rdtt->Branch("ism","TFndRawSil",&ism,64000,0);
Bdet[3] = rdtt->Branch("osm","TFndRawSil",&osm,64000,0);
Bdet[4] = rdtt->Branch("lmd","TFndRawEqp",&lmd,64000,0);
Bdet[5] = rdtt->Branch("stb","TFndRawEqp",&stb,64000,0);

// HDT branches

TFndTrig *fAgts = 0;
TBranch *BTrig = hdtt->Branch("fTrig","TFndTrig",&fAgts,64000,0);

// loop over events

UInt_t evlen=-1;
UInt_t ec=0;
Int_t istop = 0;
UInt_t *raw;
if(onlflg) {
Int_t one=1,n;
ioctl(fSockId ,FIONBIO,&one);
raw = new UInt_t[rawsize];
}
Int_t RefRunNumber = 0;
while (istop == 0) {
ec++;
cout << "process event " << ec;

// get event fron file

if(!onlflg) {
if(fread(&evlen, sizeof(UInt_t), 1 , f)!=1) {
istop = 1;
continue;
}
evlen = host2net(evlen);
raw = new UInt_t[evlen];
raw[0] = evlen;
cout << ", length " << evlen << endl;
if (1+fread(raw+1, sizeof(UInt_t), evlen-1, f) !=evlen) break;
}

// get event from socket

if(onlflg) {
struct sockaddr_in claddr;
Int_t addrlen = sizeof(struct sockaddr_in);
bzero((char *) &claddr,sizeof(struct sockaddr_in));
evlen = -1;
while(evlen == -1) {
bzero((char *) raw,sizeof(raw));
evlen = recvfrom(fSockId,raw,rawsize*sizeof(int),0,(struct
sockaddr *) &claddr,&addrlen);
usleep(10000);
}
printf(" Socket size %d Event %d addresses
%X\n",evlen,raw[0],claddr.sin_addr.s_addr);
evlen = evlen/sizeof(int);
}

// swap if needed

for (Int_t j=0; j<evlen; j++) raw[j] = host2net(raw[j]);

if(raw[13])
cout << "event 0" << endl; // next cicle if "Event 0"

// event header

hdr = new TFndHHdr(raw);

// create GenInfo object (run general information)
Int_t RunNumber = hdr->GetRun();
if(RunNumber != RefRunNumber) {
RefRunNumber = RunNumber;
if(g) delete g;
TFndGenInfo *g = new TFndGenInfo(raw);
g->Print();
g->Write();
}

// fill RDT branches

Bhdr->Fill();
gts = 0;
tof = 0;
ism = 0;
osm = 0;
lmd = 0;
stb = 0;
for (Int_t j=0; j<N_DET; j++) {
UInt_t *det = raw[7+j]? raw+raw[7+j] : (UInt_t*) NULL;
if (det) {
if(j == 0) gts = new TFndRawEqp(raw,j);
if(j == 1) tof = new TFndRawEqp(raw,j);
if(j == 2) ism = new TFndRawSil(raw,j);
if(j == 3) osm = new TFndRawSil(raw,j);
if(j == 4) lmd = new TFndRawEqp(raw,j);
if(j == 5) stb = new TFndRawEqp(raw,j);
Bdet[j]->Fill();
}
}

// create TFndRdt object

fndrdt = new TFndRdt(hdr,gts,tof,ism,osm,lmd,stb);

// create TFndHdt object

TFndHHdr *hdrf = new TFndHHdr(raw);
fAgts = new TFndTrig(tof);
fndhdt = new TFndHdt(ec,hdrf,fAgts);

// map RDT to HDT

cout << "GTS" << gts << endl;
if(gts) fndrdt->GtsTree(fndhdt,fndfeemap);
cout << "TOF" << tof << endl;
if(tof) fndrdt->TofTree(fndhdt,fndfeemap);
cout << "ISM " << ism << endl;
if(ism) fndrdt->IsmTree(fndhdt,fndfeemap);
cout << "OSM " << osm << endl;
if(osm) fndrdt->OsmTree(fndhdt,fndfeemap);
cout << "LMD " << lmd << endl;
if(lmd) fndrdt->LmdTree(fndhdt,fndfeemap);
cout << "STB " << stb << endl;
if(stb) fndrdt->StbTree(fndhdt,fndfeemap);

// fill HDT branches

cout << "TOF " << endl;
if(tof) {
fAgts = fndhdt->GetTrig();
BTrig->Fill();
}

// print multiplicities

Int_t nhtof = fndhdt->GetNHTof();
Int_t nhsil = fndhdt->GetNHSil();
Int_t nhlmd = fndhdt->GetNHLmd();
Int_t nhstb = fndhdt->GetNHStb();
Int_t nhtot = fndhdt->GetNHTot();

cout << nhtot << " hits in event " << ec << ": ";
cout << nhsil << " sil_hits, " << nhtof << " tof_hits, " << nhlmd
<< " lmd_hits, " << nhstb << " stb_hits" << endl;

// checks & output

if(!(ec%(TFndConst::kCHECK/kSCALE))) {
cout << "store on output file at event " << ec << endl;
hdr->Print();
hdtt->Print();
rdtt->Print();
of->Write();
of->cd();
of->Purge();
}

// cout << "delete raw, hdt and rdt" << endl;

delete fndrdt;
delete fndhdt;
if(!onlflg) delete [] raw;
}

// Write Events & database information
fndfeemap->Write();

of->Write();
of->cd();
of->Purge();

// Close output file
of->Close();
}