GSIWatchers.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "GSIWatchers.h"
#include "Frame.h"
#include "AgataKeyFactory.h"

#include "eventapiV50/s_filhe_swap.h"
#include "eventapiV50/s_ves10_1_swap.h"
#include "eventapiV50/s_vehe_swap.h"
#include "eventapiV50/s_evhe_swap.h"
#include "eventapiV50/s_ve10_1_swap.h"
#include "eventapiV50/s_bufhe_swap.h"
extern "C" {
#include "eventapiV50/f_evt.h"
}

using namespace Gw;

ClassImp(BaseGSIWatcher);

BaseGSIWatcher::BaseGSIWatcher() :
        TTreeWithConditions("BaseGSIWatcher", "BaseGSIWatcher",0x0),
        fMBSFrame(0x0)
{
        
}

BaseGSIWatcher::BaseGSIWatcher(const char *name, const char *title, TTree *tree) : 
        TTreeWithConditions(name, title,tree),
        fMBSFrame(0x0)
{
} 

BaseGSIWatcher::BaseGSIWatcher(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree ) : 
        TTreeWithConditions(name, title,tree, do_spectra, do_tree),
        fMBSFrame(0x0)
{
} 

BaseGSIWatcher::~BaseGSIWatcher()
{
}
        
Bool_t BaseGSIWatcher::SetTrigger( ADF::DFTrigger *trigger ) 
{
        return Watcher::GetFromTrigger(trigger, "data:ranc0", fMBSFrame);
}

/*
void BaseGSIWatcher::Exec(Option_t * option) 
{
        fDoSpectra = fDoTree = 2;

        // Clear everything
        SetLastExecStatus(0); Clear();
 
        FillBranches(); 
        fClone->Fill(); 

        // check conditions
        Short_t nb_cond = CheckCond() ; SetLastExecStatus(nb_cond);
 
        switch ( fDoSpectra ) {
                case 0:
                 break;
                case 1:
                 if ( nb_cond )
                        FillSpectra();                  
                 break;  
                case 2:
                 default:
                        FillSpectra();
                 break;
        }
        switch ( fDoTree ) {
                case 0:
                 break;
                case 1:
                        if ( nb_cond )
                                FillTree(); // GetTree()->Fill();;   
 
                break;  
                case 2:
                 default:
                         FillTree(); // GetTree()->Fill();
                break;
        } 
}
*/

ClassImp(MBSWatcher);

MBSWatcher::MBSWatcher(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir): 
        WatcherWithTag(name,title,sp_dir,tag_dir),
        fMBSFrame(0x0),
        fPrintOut(false)
{
        fEvent_dlen                     = Watcher::MakeTH1 <TH1F> ("event_dlen","Data Length",500,0,2500);
        fEvent_type                     = MakeTH1<TH1F>("event_type","Type number",100,0,200) ;
        fEvent_subtype          = MakeTH1<TH1F>("event_subtype","Subbtype",100,0,300) ;
        fEvent_trigger          = MakeTH1<TH1F>("event_trigger","Trigger Number",20,0,20) ;
        fEvent_trigger->GetXaxis()->SetBinLabel(2, "Pulser");
        fEvent_trigger->GetXaxis()->SetBinLabel(3, "LYC. Calib");
        fEvent_trigger->GetXaxis()->SetBinLabel(4, "AGA. Calib");
        fEvent_trigger->GetXaxis()->SetBinLabel(5, "HEC. Calib");
        fEvent_trigger->GetXaxis()->SetBinLabel(6, "FRS");
        fEvent_trigger->GetXaxis()->SetBinLabel(7, "Part.+#gamma(HEC.)");
        fEvent_trigger->GetXaxis()->SetBinLabel(8, "Part.+#gamma(AGA.)");
        fEvent_trigger->GetXaxis()->SetBinLabel(9, "Part.+#gamma(HEC.)+LYC.");
        fEvent_trigger->GetXaxis()->SetBinLabel(10, "Part.+#gamma(AGA.+LYC.)"); 
        fEvent_trigger->GetXaxis()->SetBinLabel(11, "Part.");   
        fEvent_trigger->GetXaxis()->SetBinLabel(12, "P");
        fEvent_trigger->GetXaxis()->SetBinLabel(13, "Spill-on");
        fEvent_trigger->GetXaxis()->SetBinLabel(14, "Spill-off");
        TagOn(fEvent_trigger);
        fEvent_count            = MakeTH1<TH1F>("event_count","Current event number",1000,0,1000) ;
        fSubEvent_dlen          = MakeTH1<TH1F>("subevent_dlen","SubEvent Data Length",1000,0,1000) ;
        fSubEvent_subtype       = MakeTH1<TH1F>("subevent_subtype","SubEvent type",5,0,5) ;
        fSubEvent_type          = MakeTH1<TH1F>("subevent_type","SubEvent Type number",20,0,20) ;
        fSubEvent_control = MakeTH1<TH1F>("subevent_control","Processor type control",50,0,50) ;
        fSubEvent_subcrate= MakeTH1<TH1F>("subevent_subcrate","Subcrate number",2,0,2) ;
        fSubEvent_procid        = MakeTH1<TH1F>("subevent_procid","Processor ID",150,0,150) ;
        
} 

void MBSWatcher::DoCanvas(TCanvas *c, Option_t *opt)
{
        TString option = opt;
        c->Divide(2,2,0.001,0.001);

        c->cd(1); fEvent_trigger->Draw();
        c->cd(2); fEvent_dlen->Draw();  
        c->cd(3); fSubEvent_dlen->Draw();
        c->cd(4); fSubEvent_procid->Draw();  
}

Bool_t MBSWatcher::SetTrigger( ADF::DFTrigger *trigger ) 
{
        return Watcher::GetFromTrigger(trigger, "data:ranc0", fMBSFrame);
}

void MBSWatcher::PrintOut(Bool_t ison)
{
        fPrintOut = ison;
}

void MBSWatcher::Exec(Option_t * /*option*/) 
{       
        ADF::RawFrame *rframe = 0x0; ADF::AgataKey *key; Int_t *pMBSData = 0x0; Int_t event_type, event_subtype, event_number;
        
        // be sure the frame has been set properly
        if ( fMBSFrame == 0x0 || !fMBSFrame->IsValid() ) { 
                SetLastExecStatus(1); 
                return; 
        }
        else {
                // ADF part
                rframe = 
                (ADF::RawFrame *)fMBSFrame->GetFrame();
                key = dynamic_cast<ADF::AgataKey *> (rframe->GetKey()); event_number = key->GetEventNumber();
                
                //      MBS part        
                pMBSData = (Int_t *)(rframe->RawBuffer().Address());            
        }
        // read pseudo ADF key in the MBS part
        ADF_MBS *ADF_MBS_Key = (ADF_MBS *)pMBSData;
        
        if ( ADF_MBS_Key->idmbs == 0x100 || ADF_MBS_Key->idmbs == 0x200 ) { // well formed 'event'
                event_type = 10 ; event_subtype = 1;
        }
        else {
                event_type = ADF_MBS_Key->type; event_subtype = ADF_MBS_Key->subtype;
        }
        
        //
        //if( ! fUnpacker->CheckEventHeader(ADF_MBS_Key->dlen, event_type, event_subtype, 0,
        //                                                                                       ADF_MBS_Key->trigger, event_number,
   //                                  fUnpackData) ) { cout << " WRONG Event header" << endl; return; }
        
        fEvent_dlen->Fill(ADF_MBS_Key->dlen);
        fEvent_subtype->Fill(event_subtype);    
        fEvent_type->Fill(event_type);
        fEvent_trigger->Fill(ADF_MBS_Key->trigger);
        fEvent_count->Fill(event_number);
        
        if ( fPrintOut ) {
                cout << " ADF_MBS_Key->dlen "  << ADF_MBS_Key->dlen << " ADF_MBS_Key->idmbs 0x" << hex << ADF_MBS_Key->idmbs << endl;
                cout << dec;
        }
        
        // now read all sub_event using eventAPI facilities ... cannot be done, no event header !
        
        // -3 is because apparently the coded value doest not take into account additional TS,ev# in the ADF_MBS_Key structure
        Int_t i_nrest  = (ADF_MBS_Key->dlen+4)/2 - 4 - 3; 
        // or
        //      Int_t i_nrest  = rframe->GetKey()->GetDataLength()/4 - sizeof(ADF_MBS_Key)/4;
        
        Int_t i_offset = 7; // first sub event starts at 7*4 bytes in the Data part of the Raw Frame 
        
        //      fOffset.clear();
        while (i_nrest >= 3) {
                //      while (i_nrest > 3) {
                
                const s_ves10_1* p_subhead = (const s_ves10_1*)(pMBSData+i_offset);
                Int_t i_size  = (p_subhead->l_dlen-2)/2;
                Int_t i_styp  = p_subhead->i_subtype;
                Int_t i_typ   = p_subhead->i_type;
                Int_t i_cont  = p_subhead->h_control;
                Int_t i_crate = p_subhead->h_subcrate;
                Int_t i_proc  = p_subhead->i_procid;
                
                fSubEvent_dlen->Fill(i_size);
                fSubEvent_subtype->Fill(i_styp);
                fSubEvent_type->Fill(i_typ);
                fSubEvent_control->Fill(i_cont);
                fSubEvent_subcrate->Fill(i_crate);
                fSubEvent_procid->Fill(i_proc);
                
                if (fPrintOut) {
                        cout << endl << " **** Subevent, i_nrest " << i_nrest << " should be >= 3 " << endl;
                        cout << "i_size " << i_size << " i_styp " << i_styp << " i_typ " << i_typ 
                        << " i_control " << i_cont << " i_subcrate " << i_crate << " i_proc " << i_proc  << endl ;
                }
                // now apply unpacker ... just for test 
                // fUnpacker->UnpackSubevent(i_typ, i_styp, i_size, i_proc, i_cont, ADF_MBS_Key->trigger, 
                //                                                                pMBSData + i_offset + 3, 
                //                                                                fUnpackData) ;
                i_nrest  -= i_size + 3;
                i_offset += i_size + 3;
                
        }
        
        /*
         // now read all sub_event using eventAPI facilities ... cannot be done, no event header !
         Int_t *event_data = pMBSData + 7;
         int result = 1;
         for (int sub = 0; result != GETEVT__NOMORE; ++sub)
         {
         cout << " --> SUB " << sub << " " << hex << event_data[0] << " " << event_data[1] << endl;
         
         s_ves10_1 *p_subhead = 0; INTS4 *data = 0; INTS4 length = 0; 
         //
         result = f_evt_get_subevent((s_ve10_1*)(event_data), sub, (INTS4**)&p_subhead, (INTS4**)&data, &length);
         if (result == GETEVT__SUCCESS && p_subhead)
         {                              
         Int_t i_size  = (p_subhead->l_dlen-2)/2;
         Int_t i_typ   = p_subhead->i_type;
         Int_t i_styp  = p_subhead->i_subtype;
         Int_t i_pid   = p_subhead->i_procid;
         Int_t i_ptyp  = p_subhead->h_control;
         Int_t i_crate = p_subhead->h_subcrate;
         
         cout << "i_size " << i_size << " i_typ " << i_typ << " i_styp " 
         << i_styp << " i_pid " << i_pid << " i_ptyp " << i_ptyp << " i_crate " << i_crate << endl ;
         
         fSubEvent_dlen->Fill(i_size);
         fSubEvent_type->Fill(i_typ);
         fSubEvent_subtype->Fill(i_styp);
         fSubEvent_control->Fill(i_pid);
         fSubEvent_subcrate->Fill(i_ptyp);
         fSubEvent_procid->Fill(i_crate);
         
         }
         }
         */
}


/*
TH1I* TSPEBasicProc::MakeH1I(const char* fname, 
                                                                          const char* hname,
                                                                          Int_t nbinsx, 
                                                                          Float_t xmin, Float_t xmax, 
                                                                          const char* xtitle,
                                                                          Color_t linecolor,
                                                                          Color_t fillcolor,
                                                                          const char* ytitle) {
   TNamed* res = TestObject((getfunc)&TGo4EventProcessor::GetHistogram, fname, hname);
   if (res!=0) return dynamic_cast<TH1I*>(res);
   
   TH1I* histo = new TH1I(hname, hname, nbinsx, xmin, xmax);
   histo->SetXTitle(xtitle);
   if (ytitle) histo->SetYTitle(ytitle);
   histo->SetLineColor(linecolor); 
   histo->SetFillColor(fillcolor);
   AddHistogram(histo, fname);
   return histo;
}

TH1I* TSPEBasicProc::MakeH1IArray(const char* foldername, 
                                                                                         const char* name, const char* name_ext,
                                                                                         Int_t nbinsx, 
                                                                                         Float_t xmin, Float_t xmax, 
                                                                                         const char* xtitle,
                                                                                         Color_t linecolor,
                                                                                         Color_t fillcolor)
{
        char fullname[150];
        sprintf(fullname,"%s%s",name_ext, name);
        
        return MakeH1I(foldername, fullname, nbinsx, xmin, xmax, xtitle, linecolor, fillcolor);
}


TH2I* TSPEBasicProc::MakeH2I(const char* fname, 
                             const char* hname,
                             Int_t nbinsx, Float_t xmin, Float_t xmax, 
                             Int_t nbinsy, Float_t ymin, Float_t ymax, 
                             const char* xtitle, const char* ytitle,
                             Color_t markercolor) {
   TNamed* res = TestObject((getfunc)&TGo4EventProcessor::GetHistogram, fname, hname);
   if (res!=0) return dynamic_cast<TH2I*>(res);
   
   TH2I* histo = new TH2I(hname, hname, nbinsx, xmin, xmax, nbinsy, ymin, ymax);
   histo->SetMarkerColor(markercolor);
   histo->SetXTitle(xtitle);
   histo->SetYTitle(ytitle);
   AddHistogram(histo, fname);
   return histo;
}

TH1I* TSPEBasicProc::MakeH1ISeries(const char* foldername,
                                                                                          Int_t seriesnumber,
                                                                                          Int_t crate,
                                                                                          Int_t number,
                                                                                          Int_t nbins, 
                                                                                          Float_t xmin, Float_t xmax, 
                                                                                          Bool_t remove)
{
        char fullfoldername[100];                                    
        sprintf(fullfoldername,"%s/%02d", foldername, seriesnumber);
        char histoname[50];
        sprintf(histoname,"newVME%02d_%02d_%02d", crate, seriesnumber, number); 
        if (remove) {
                char fullname[200]; 
                sprintf(fullname,"%s/%s",fullfoldername,histoname);
                RemoveHistogram(fullname); 
                return 0;   
        }
        return MakeH1I(fullfoldername, histoname, nbins, xmin, xmax);
}

*/