Bool_t KVGANILDataReader::GetNextEvent()
{
// Read next event in raw data file.
// Returns false if no event found (end of file).
// The list of all fired acquisition parameters is filled, and can be retrieved with
// GetFiredDataParameters().
// If SetUserTree(TTree*) has been called, the TTree is filled with the values of all
// parameters in this event.
Bool_t ok = fGanilData->Next();
FillFiredParameterList();
if( fUserTree ){
if( make_arrays ){
NbParFired = fFired->GetEntries();
TIter next(fFired); KVACQParam* par;
int i=0;
while( (par = (KVACQParam*)next()) ){
ParVal[i] = par->GetCoderData();
ParNum[i] = par->GetNumber();
i++;
}
}
fUserTree->Fill();
}
return ok;
}
UInt_t KVHarpeeIC::GetFiredSegNumber(Option_t* opt)
{
// return the number of the fired segment of this Harpee ionisation chamber
// ( number between 1 to 7 ). Returns 0 if no segment or several segments
// are fired. A segment is considered as fired if at least one of its 3
// acquisition parameters (A, B and C) is fired (KVACQParam::Fired( opt )).
// Set the option opt = "P" to accept only the acquisition parameters with
// their value above the pedestal.
TIter next(GetACQParamList());
KVACQParam* par = NULL;
UInt_t num = 0;
while ((par = (KVACQParam*)next())) {
if (par->Fired(opt)) {
if (num && (num != par->GetNumber())) return 0;
num = par->GetNumber();
}
}
return num;
}
void KVGANILDataReader::SetUserTree(TTree* T, Option_t* opt)
{
// To fill a TTree with the data in the current file, create a TTree:
// TFile* file = new TFile("run1.root","recreate");
// TTree* T = new TTree("Run1", "Raw data for Run1");
// and then call this method: SetUserTree(T)
// If you read all events of the file, the TTree will be automatically filled
// with data :
// while( runfile->GetNextEvent() ) ;
//
// Two different TTree structures are available, depending on the option string:
//
// opt = "arrays": [default]
//
// The TTree will have the following structure:
//
// *Br 0 :NbParFired : NbParFired/I = number of fired parameters in event
// *............................................................................*
// *Br 1 :ParNum : ParNum[NbParFired]/i = array of indices of fired parameters
// *............................................................................*
// *Br 2 :ParVal : ParVal[NbParFired]/s = array of values of fired parameters
//
// This structure is the fastest to fill and produces the smallest file sizes.
// In order to be able to directly access the parameters as if option "leaves" were used
// (i.e. one branch/leaf for each parameter), we add two aliases for each parameter to
// the tree:
// PARNAME = value of parameter if present in event
// PARNAME_M = number of times parameter appears in event
// Assuming that each parameter only appears at most once in each event, i.e. PARNAME_M=0 or 1,
// then
// root[0] T->Draw("PARNAME", "PARNAME_M")
// will histogram the value of PARNAME for each event in which it is present.
// (if the selection condition "PARNAME_M" is not used, the histogram will also be filled with a 0
// for each event in which PARNAME does not appear).
// N.B. the PARNAME alias is in fact the sum of the values of PARNAME in each event.
// If PARNAME_M>1 in some events, it is not the individual values but their sum which will
// be histogrammed in this case.
//
// Thus, if the data file has parameters called "PAR_1" and "PAR_2",
// the following command will work
//
// root[0] T->Draw("PAR_1:PAR_2", "PAR_1_M&&PAR_2_M", "col")
//
// even though no branches "PAR_1" or "PAR_2" exist.
//
//
//
// opt = "leaves":
//
// The TTree will have a branch/leaf for each parameter. This option is slower and produces
// larger files.
//
// If the option string contains both "arrays" and "leaves", then both structures will be used
// (in this case there is a high redundancy, as each parameter is stored twice).
//
// The full list of parameters is stored in a TObjArray in the list returned by TTree::GetUserInfo().
// Each parameter is represented by a TNamed object.
// In order to retrieve the name of the parameter with index 674 (e.g. taken from branch ParNum),
// do:
// TObjArray* parlist = (TObjArray*) T->GetUserInfo()->FindObject("ParameterList");
// cout << "Par 674 name = " << (*parlist)[674]->GetName() << endl;
//
//
// Automatic creation & filling of Scalers TTree
//
// give an option string containing "scalers", i.e. "leaves,scalers", or "ARRAYS+SCALERS", etc.
// a TTree with name 'Scalers' will be created, all scaler buffers will be written in it.
TString option = opt;
option.ToUpper();
make_arrays = option.Contains("ARRAYS");
make_leaves = option.Contains("LEAVES");
Bool_t make_scalers = option.Contains("SCALERS");
if(make_scalers){
fGanilData->SetScalerBuffersManagement(GTGanilData::kAutoWriteScaler);
}
fUserTree = T;
if( make_arrays ){
Int_t maxParFired = GetRawDataParameters()->GetEntries();
ParVal = new UShort_t[maxParFired];
ParNum = new UInt_t[maxParFired];
fUserTree->Branch("NbParFired", &NbParFired, "NbParFired/I");
fUserTree->Branch("ParNum", ParNum, "ParNum[NbParFired]/i");
fUserTree->Branch("ParVal", ParVal, "ParVal[NbParFired]/s");
}
if( make_leaves ){
TIter next_rawpar( GetRawDataParameters() );
KVACQParam* acqpar;
while( (acqpar = (KVACQParam*)next_rawpar()) ){
TString leaf;
leaf.Form("%s/S", acqpar->GetName());
// for parameters with <=8 bits only use 1 byte for storage
if(acqpar->GetNbBits()<=8) leaf += "1";
fUserTree->Branch( acqpar->GetName(), *(acqpar->ConnectData()), leaf.Data() );
}
}
#if ROOT_VERSION_CODE > ROOT_VERSION(5,25,4)
#if ROOT_VERSION_CODE < ROOT_VERSION(5,26,1)
// The TTree::OptimizeBaskets mechanism is disabled, as for ROOT versions < 5.26/00b
// this lead to a memory leak
fUserTree->SetAutoFlush(0);
#endif
#endif
// add list of parameter names in fUserTree->GetUserInfos()
// and if option="arrays" add aliases for each parameter & its multiplicity
// TObjArray has to be as big as the largest parameter number in the list
// of raw data parameters. So first loop over parameters to find max param number.
UInt_t maxpar = 0;
TIter next(GetRawDataParameters());
KVACQParam* par;
while( (par=(KVACQParam*)next()) ) if (par->GetNumber()>maxpar) maxpar=par->GetNumber();
TObjArray *parlist = new TObjArray(maxpar,1);
parlist->SetName("ParameterList");
next.Reset();
while( (par = (KVACQParam*)next()) ){
parlist->AddAt( new TNamed( par->GetName(), Form("index=%d",par->GetNumber()) ), par->GetNumber() );
if( make_arrays ){
fUserTree->SetAlias( par->GetName(), Form("Sum$((ParNum==%d)*ParVal)", par->GetNumber() ) );
fUserTree->SetAlias( Form("%s_M", par->GetName()), Form("Sum$(ParNum==%d)", par->GetNumber() ) );
}
}
fUserTree->GetUserInfo()->Add(parlist);
}
void KVVAMOSDetector::SetCalibrators()
{
// Setup the calibrators for this detector. Call once name
// has been set.
// The calibrators are KVFunctionCal.
// By default the all the calibration functions are first-degree
// polynomial function and the range [Xmin,Xmax]=[0,4096].
// Here the calibrator are not ready (KVFunctionCal::GetStatus()).
// You have to give the parameters and change the status
// (see KVFunctionCal::SetParameter(...) and KVFunctionCal::SetStatus(...))
TIter nextpar(GetACQParamList());
KVACQParam* par = NULL;
Double_t maxch = 16384.; // 14 bits
TString calibtype("ERROR");
while ((par = (KVACQParam*)nextpar())) {
Bool_t isTparam = kFALSE;
if (par->IsType("E")) {
calibtype = "channel->MeV";
} else if (par->IsType("Q")) {
calibtype = "channel->Volt";
maxch = 4096.; // 12 bits
} else if (par->GetType()[0] == 'T') {
isTparam = kTRUE;
calibtype = "channel->ns";
} else continue;
calibtype.Append(" ");
calibtype.Append(par->GetName());
TF1* func = new TF1(calibtype.Data(), "pol1", 0., maxch);
KVFunctionCal* c = new KVFunctionCal(this, func);
c->SetType(calibtype.Data());
c->SetLabel(par->GetLabel());
c->SetNumber(par->GetNumber());
c->SetUniqueID(par->GetUniqueID());
c->SetACQParam(par);
c->SetStatus(kFALSE);
if (!AddCalibrator(c)) delete c;
else if (isTparam) {
if (!fTlist) fTlist = new TList;
fTlist->Add(par);
if (!fT0list) fT0list = new TList;
fT0list->Add(new KVNamedParameter(par->GetName(), 0.));
}
}
// Define and set to zero the T0 values for time of flight measurment
// from this detector. The time of flight acq parameters are associated
// to gVamos
if (gVamos) {
TIter next_vacq(gVamos->GetVACQParams());
while ((par = (KVACQParam*)next_vacq())) {
if ((par->GetType()[0] == 'T') && IsStartForT(par->GetName() + 1)) {
if (!fTlist) fTlist = new TList;
fTlist->Add(par);
if (!fT0list) fT0list = new TList;
fT0list->Add(new KVNamedParameter(par->GetName(), 0.));
}
}
}
}