GSIPrespecWatchers.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.             *
 ***************************************************************************/

// ROOT/GW includes
#include "GSIPrespecWatchers.h"
#include "Frame.h"
#include "AgataKeyFactory.h"
#include "TH2.h"

// Prespec includes
#include "UnpackData.h"
#include "UnpackLib.h"
#include "SortData.h"
#include "SortLib.h"
#include "FRSCalibrData.h"
#include "FRSCalibr.h"
#include "HectorCalibrData.h"
#include "HectorCalibr.h"
#include "FRSAnl.h"
#include "FRSAnlData.h"
#include "LyccaLib.h"
#include "LyccaData.h"

// system includes 
#include <cstdlib>

#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(Unpack);

//Unpack::Unpack(const char *name, const char *title, TTree *tree) : 
//      BaseGSIWatcher(name,title,tree),
//       fUnpackData(0x0),
//        fUnpacker(0x0),
//        fsis(8)
//{
//      fUnpackData = new UnpackData(); fUnpacker = new PhDUnpacker();
//
//      if ( GetTree() ) { // just add the branch for that watcher ... should be there as AddBranches is virtual and should be in this class
//              SetBranches();
//      }
//      // usser's spectra
//    BuildSpectraByUser();
//}

Unpack::Unpack(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree) : 
        BaseGSIWatcher(name,title,tree,do_spectra,do_tree),
        fUnpackData(0x0),
        fUnpacker(0x0),
        fsis(8)
{
        fUnpackData = new UnpackData(); fUnpacker = new PhDUnpacker();

        if ( GetTree() ) { // just add the branch for that watcher ... should be there as AddBranches is virtual and should be in this class
                SetBranches();
        }
        // usser's spectra
    BuildSpectraByUser();
}

Unpack::~Unpack()
{
       if ( fUnpackData )
        delete fUnpackData;

       if ( fUnpacker ) 
        delete fUnpacker;
}

void Unpack::AddBranches(TTree *tree)
{
        tree->Branch("UnpackData","UnpackData",&fUnpackData,32000,99);
}


void Unpack::FillBranches()
{
        ADF::RawFrame *rframe = 0x0; Int_t *pMBSData = 0x0;
        
        //      if ( gDebug > 3 ) 
        // fLog << info << "BaseGSIWatcher::Exec is called 1 \n" << dolog;
//  cout << "Fill branch unpack " << endl;
        
        // be sure the frame has been set properly
        if ( fMBSFrame == 0x0 || !fMBSFrame->IsValid() ) { 
//    cout << " ***Wrong frame " << endl;
                SetLastExecStatus(-1); 
                return; 
        }
        if ( fMBSFrame == 0x0 || !fMBSFrame->IsValid() ) { 
                SetLastExecStatus(-1); 
                return; 
        }       
        // ADF part
        rframe = 
                (ADF::RawFrame *)fMBSFrame->GetFrame();
        //      MBS part        + pseudo ADF key in the MBS part
        pMBSData = (Int_t *)(rframe->RawBuffer().Address()); ADF_MBS *ADF_MBS_Key = (ADF_MBS *)pMBSData;
        
        if ( ADF_MBS_Key->idmbs == 0x100  ) { // well formed 'event'
                ADF_MBS_Key->type = 10 ; ADF_MBS_Key->subtype = 1;
        }
   //    cout <<  "trigger" << ADF_MBS_Key->trigger << endl;

        if( !fUnpacker->CheckEventHeader(ADF_MBS_Key->dlen, ADF_MBS_Key->type, ADF_MBS_Key->subtype, 
                                     ADF_MBS_Key->dummy, ADF_MBS_Key->trigger , ADF_MBS_Key->count,
                                     fUnpackData) ){

//            cout << " ***Wrong imbs frame " << endl;
            SetLastExecStatus(-1) ; 
            return;
       }


        // now read all sub_event using eventAPI facilities ... cannot be done, no event header !
        
        // -3 is because apparently the coded value does 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) {
                
                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;  //Not Used variables.
                Int_t i_proc  = p_subhead->i_procid;
                
                // now apply unpacker 
                fUnpacker->UnpackSubevent(i_typ, i_styp, i_size, i_proc, i_cont, ADF_MBS_Key->trigger,                                                          pMBSData + i_offset + 3, 
                                                        fUnpackData);
        //if ( fUnpacker->UnpackSubevent(i_typ, i_styp, i_size, i_proc, i_cont, ADF_MBS_Key->trigger, 
        //                                                                        pMBSData + i_offset + 3, 
        //                                                                        fUnpackData) == 0 ) SetLastExecStatus(-1);
                i_nrest  -= i_size + 3;
                i_offset += i_size + 3;
                
        }
}

void Unpack::Clear(Option_t * /*opt */)
{
        fUnpackData->Clear();
}


void Unpack::BuildSpectraByUser()
{
        // VME 12 is important ... hit pattern of lLYCCA strips ... should be used to have an uniform response          

        Int_t i;
        TString name = "";
        for (i=0;i<fsis.GetSize();i++){
                name = "raw_sis_";
                name+=i;
                fsis.Add( MakeTH1 <TH1F>( (const Char_t*) name,"Raw data for SIS module",6000,0,6000,"VME_AGATA") );  
        }
        // Add a conditions name, title of condition, leaf it applies on, name, title of the associated spectrum
        std::pair <GCond1D *, TH1 * > r1 = MakeGCond1D("C_qtrigger","Cut On qtrigger","qtrigger","qtrigger","qtrigger distribution",20,0,20);
}

void Unpack::FillSpectraByUser() 
{
  Int_t i;
  for (i=0;i<fsis.GetSize();i++){
    ((TH1 *)fsis[i])->Fill(fUnpackData->energyArray[i]);
  }
}

// SORT branch of the prespec LIB

ClassImp(Sort);

Sort::Sort(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree) : 
        BaseGSIWatcher(name,title,tree,do_spectra,do_tree),
        fUnpackData(0x0),
        fSortData(0x0),
        fSortClass(0x0)
{
     Unpack *unpack_w = (Unpack *)Watcher::GetLastRegistered("Unpack","class");
     if ( unpack_w == 0x0 ) {
        fLog << error << " AN Unpack watcher should be registered before " << nline;
     }
     else fUnpackData = unpack_w->GetUnpackData();
                
        fSortData = new SortData(); fSortClass = new SortClass();

        if ( GetTree() ) { // just add the branch for that watcher ... should be there as AddBranches is virtual and should be in this class
                SetBranches();
        }

        // usser's spectra
    BuildSpectraByUser();
}

Sort::~Sort()
{
        if ( fSortData ) 
                delete fSortData;
        if ( fSortClass ) 
                delete fSortClass;
}

void Sort::BuildSpectraByUser()
{
        fTrigger = MakeTH1 <TH1F>("Sort.trigger","Trigger @ the Sort level",20,0,20);
}

void Sort::FillSpectraByUser()
{
        fTrigger->Fill( fSortData->trigger );
}

void Sort::AddBranches(TTree *tree)
{
        tree->Branch("SortData","SortData",&fSortData,32000,99);
}

void Sort::FillBranches()
{
  //Add here the function for the data processing
  fSortClass->FRSSort(fUnpackData,fSortData);    //DR: ATT, not respecting const param, check it in the prespecLIB
  fSortClass->HectorSort(fUnpackData,fSortData);         //DR: ATT, not respecting const param, check it in the prespecLIB
  fSortClass->LyccaSort(fUnpackData,fSortData);  //DR: ATT, not respecting const param, check it in the prespecLIB
  fSortClass->AgataTSort(fUnpackData,fSortData);         //DR: ATT, not respecting const param, check it in the prespecLIB
  fSortClass->FingerSort(fUnpackData,fSortData);         //DR: ATT, not respecting const param, check it in the prespecLIB
#ifdef TRLO_F
  fSortClass->TrloSort(fUnpackData,fSortData);   //DR: ATT, not respecting const param, check it in the prespecLIB
#endif //TRLO_F
}

void Sort::Clear(Option_t * /*opt */)
{
        fSortData->Clear();
}

// Calib branch of the prespec LIB //

ClassImp(Calibr);

Calibr::Calibr(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree) : 
        BaseGSIWatcher(name,title,tree,do_spectra,do_tree),
        fSortData(0x0),
        fFRSCalibrData(0x0),
        fHectorCalibrData(0x0),
        fFRSCalibr(0x0),
        fHectorCalibr(0x0)
{
        Sort *sort_w = (Sort *)Watcher::GetLastRegistered("Sort","class");
        if ( sort_w  == 0x0 ) {
                fLog << error << " A Sort watcher should be registered before " << nline;
        }
        else {
 //               fLog << error << " ******************** Ok ****************** " << dolog;
                fSortData = sort_w->GetSortData();
        }       

        fFRSCalibrData = new FRSCalibrData(); fFRSCalibr = new FRSCalibr();
        fHectorCalibrData = new HectorCalibrData(); fHectorCalibr = new HectorCalibr();

        if ( GetTree() ) { // just add the branch for that watcher ... should be there as AddBranches is virtual and should be in this class
                SetBranches();
        }
        // usser's spectra
    BuildSpectraByUser();

        fLog << dolog;
}

Calibr::~Calibr()
{
        if ( fFRSCalibrData )
                delete fFRSCalibrData;
        if ( fFRSCalibr )
                delete fFRSCalibr;
        if ( fHectorCalibrData )
                delete fHectorCalibrData;
        if ( fHectorCalibr )
                delete fHectorCalibr;
}

void Calibr::BuildSpectraByUser()
{
        fTrigger = MakeTH1 <TH1F>("Calibr.trigger","Trigger @ the Calibr level",20,0,20);
}

void Calibr::FillSpectraByUser()
{
        fTrigger->Fill(fFRSCalibrData->triggerC );
}

void Calibr::AddBranches(TTree *tree)
{
        tree->Branch("FRSCalibrData","FRSCalibrData",&fFRSCalibrData,32000,99);
        tree->Branch("HectorCalibrData","HectorCalibrData",&fHectorCalibrData,32000,99);
}

void Calibr::FillBranches()
{
  //Add here the function for the data processing
  fFRSCalibr->Process_FRS_Calibr(fSortData,fFRSCalibrData); // Process all FRS
  fHectorCalibr->Hector_Cal(fSortData,fHectorCalibrData);
}

void Calibr::Clear(Option_t * /*opt */)
{
        fFRSCalibrData->Clear();
        fHectorCalibrData->Clear();
}

ClassImp(Anl);

Anl::Anl(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree) : 
        BaseGSIWatcher(name,title,tree,do_spectra,do_tree),
        fSortData(0x0),
        fFRSCalibrData(0x0),
        fHectorCalibrData(0x0),
        fFRSAnl(0x0),
        fFRSAnlData(0x0),
        fLyccaLib(0x0),
        fLyccaData(0x0)
{
        Sort *sort_w = (Sort *)Watcher::GetLastRegistered("Sort","class");
        if ( sort_w  == 0x0 ) {
                fLog << error << " A Sort watcher should be registered before " << nline;
        }
        else fSortData = sort_w->GetSortData();

        Calibr *calib_w = (Calibr *)Watcher::GetLastRegistered("Calibr","class");
        if ( calib_w  == 0x0 ) {
                fLog << error << " A Calib watcher should be registered before " << nline;
        }
        else {
                fFRSCalibrData = calib_w->GetFRSCalibrData();
                fHectorCalibrData = calib_w->GetHectorCalibrData();
        }
  
          //ANALAYSE FRS
        fFRSAnlData = new FRSAnlData(); fFRSAnl = new FRSAnl();
        fLyccaData = new LyccaData(); fLyccaLib = new LyccaLib();

        if ( GetTree() ) { // just add the branch for that watcher ... should be there as AddBranches is virtual and should be in this class
                SetBranches();
        }
        // usser's spectra
    BuildSpectraByUser();

        fLog << dolog;
}

Anl::~Anl()
{
        if ( fFRSAnlData )
                delete fFRSAnlData;
        if ( fFRSAnl )
                delete fFRSAnl;
        if ( fLyccaData )
                delete fLyccaData;
        if ( fLyccaLib )
                delete fLyccaLib;
}

void Anl::BuildSpectraByUser()
{
        fTa_PvsN = MakeTH2 <TH2F>("Calibr.TA_PvsN","Target DSSD P energy vs N energy",1000,0,2000,1000,0,2000);
        fTa_PvsP = MakeTH2 <TH2F>("Calibr.TA_PvsP","Target DSSD P energy vs P energy",1000,0,2000,1000,0,2000);
        fTa_NvsN = MakeTH2 <TH2F>("Calibr.TA_NvsN","Target DSSD N energy vs N energy",1000,0,2000,1000,0,2000);
        fTa_N_strip = MakeTH2 <TH2F>("Calibr.N_strip","Target DSSD N energy vs strip number",32,0,32,1000,0,2000);
        fTa_P_strip = MakeTH2 <TH2F>("Calibr.P_strip","Target DSSD P energy vs strip number",32,0,32,1000,0,2000);

  fWall_D06_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D06_PvsN","Wall DSSD module 06, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D07_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D07_PvsN","Wall DSSD module 07, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D11_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D11_PvsN","Wall DSSD module 11, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D12_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D12_PvsN","Wall DSSD module 12, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D13_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D13_PvsN","Wall DSSD module 13, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D14_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D14_PvsN","Wall DSSD module 14, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D18_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D18_PvsN","Wall DSSD module 18, P versus N side",1000,0,2000,1000,0,2000);
  fWall_D19_NvsP = MakeTH2 <TH2F>("Calibr.Wall_D19_PvsN","Wall DSSD module 19, P versus N side",1000,0,2000,1000,0,2000);

}

void Anl::FillSpectraByUser()
{
  for(int i=0;i<31;i++){
    for(int j=0;j<31;j++){
      fTa_PvsN->Fill(fLyccaData->t_DSSD_EcalN[i],fLyccaData->t_DSSD_EcalP[j]);
      fTa_PvsP->Fill(fLyccaData->t_DSSD_EcalP[i],fLyccaData->t_DSSD_EcalP[j]);
      fTa_NvsN->Fill(fLyccaData->t_DSSD_EcalN[i],fLyccaData->t_DSSD_EcalN[j]);
      }
      fTa_N_strip->Fill(i,fLyccaData->t_DSSD_EcalN[i]);
      fTa_P_strip->Fill(i,fLyccaData->t_DSSD_EcalP[i]);
  }
  //Fill spectra of the wall DSSD
  for (int i=0;i<16;i++){
    for(int j=0;j<16;j++){
      fWall_D06_NvsP->Fill(fLyccaData->w_DSSD_EcalN[06][i],fLyccaData->w_DSSD_EcalP[06][j]);
      fWall_D07_NvsP->Fill(fLyccaData->w_DSSD_EcalN[07][i],fLyccaData->w_DSSD_EcalP[07][j]);
      fWall_D11_NvsP->Fill(fLyccaData->w_DSSD_EcalN[11][i],fLyccaData->w_DSSD_EcalP[11][j]);
      fWall_D12_NvsP->Fill(fLyccaData->w_DSSD_EcalN[12][i],fLyccaData->w_DSSD_EcalP[12][j]);
      fWall_D13_NvsP->Fill(fLyccaData->w_DSSD_EcalN[13][i],fLyccaData->w_DSSD_EcalP[13][j]);
      fWall_D14_NvsP->Fill(fLyccaData->w_DSSD_EcalN[14][i],fLyccaData->w_DSSD_EcalP[14][j]);
      fWall_D18_NvsP->Fill(fLyccaData->w_DSSD_EcalN[18][i],fLyccaData->w_DSSD_EcalP[18][j]);
      fWall_D19_NvsP->Fill(fLyccaData->w_DSSD_EcalN[19][i],fLyccaData->w_DSSD_EcalP[19][j]);
    }
  }
}


void Anl::AddBranches(TTree *tree)
{
        tree->Branch("FRSAnlData","FRSAnlData",&fFRSAnlData,32000,99);
        tree->Branch("LyccaData","LyccaData",&fLyccaData,32000,99);
}

void Anl::FillBranches()
{
        //ANALYSE FRS
        fFRSAnl->Process_FRS_IDS(fFRSAnlData,fFRSCalibrData);
        fLyccaLib->ProcessLycca(fSortData,fFRSCalibrData,fFRSAnlData,fLyccaData);
}

void Anl::Clear(Option_t * /* opt */ )
{
        fFRSAnlData->Clear();
        fLyccaData->Clear();
}

ClassImp(LightLYCCAVertexBuilder_1);

LightLYCCAVertexBuilder_1::LightLYCCAVertexBuilder_1(const char *name, const char *title):
    Gw::WatcherWithTag(name, title,0x0,0x0),
    VertexBuilder(),
    fMeanBeta(0.5),
    fZTa_Wall(3670.),
    fZTDSSDOffset(0.0),
    fcosTheta(0.0)
{
  //3590 -> 3670 as distance
        // use to pass the vertex information from this watcher to another watcher
        fVertexFrame = MainFrameFactory::theMainFactory().
        NewSharedFrame( FactoryItem("Agata","meta:vertex",Version(0,0)), FactoryItem("Agata","meta:vertex",Version(1,1)) );
        fIsToBeDeleted = true;
        
        // data provided by analysis are required
        Anl *anl_w = (Anl *)Watcher::GetLastRegistered("Anl","class");
        if ( anl_w  == 0x0 ) {
                fLog << error << " A Anl watcher should be registered before " << nline;
        }
  fLyccaData = anl_w->GetLyccaData();
}

void LightLYCCAVertexBuilder_1::SetTA_Wall(Double_t z_tdssd_offset, Double_t ta_wall)
{
        fZTa_Wall = ta_wall; fZTDSSDOffset = z_tdssd_offset;
}

void LightLYCCAVertexBuilder_1::SetMeanBeta(Double_t beta)
{
        fMeanBeta = beta;
}

void LightLYCCAVertexBuilder_1::SetBeta()
{
        fMeanBeta = fLyccaData->LYCCA_Beta_Cor;
}

void LightLYCCAVertexBuilder_1::SetTheta(Double_t cosTheta)
{
        fcosTheta=cosTheta;
}

Double_t LightLYCCAVertexBuilder_1::GetTheta()
{
        return fcosTheta;
}
void LightLYCCAVertexBuilder_1::SetPosWall(Double_t xw,Double_t yw, Double_t zw)
{
  fWallPosx=xw;         fWallPosy=yw;   fWallPosz=zw;
 //     cout << fWallPosx <<" " << fWallPosy << " " << fWallPosz << endl;
  
}

void LightLYCCAVertexBuilder_1::GetPosWall(Double_t & xw,Double_t &yw, Double_t & zw)
{
        xw=fWallPosx;   yw=fWallPosy;   zw=fWallPosz;
  //    cout << fWallPosx <<" " << fWallPosy << " " << fWallPosz << endl;
//      cout << xw <<" " << yw << " " << zw << endl;
}

void LightLYCCAVertexBuilder_1::Exec(Option_t * /*option*/)
{
        // prepare the vertex so that it is defined in the agata reference system using fZTDSSDOffset.
        // Is is the Z position of target DSSD in AGATA Frameworkork
        // fZTDSSDOffset > 0 means target DSSD is in positive direction compared to agata center (following beam direction)
        // fZTDSSDOffset < 0 means target DSSD is in negative direction compared to agata center (following beam direction)
//   SetVertex(fLyccaData->Pos_target_x1,fLyccaData->Pos_target_y1,fZTDSSDOffset,
//              fLyccaData->w_DSSD_x-fLyccaData->Pos_target_x1,fLyccaData->w_DSSD_y-fLyccaData->Pos_target_y1,fZTa_Wall,
//              fMeanBeta);
  //Other posisition/vertex
  LightLYCCAVertexBuilder_1::SetBeta();
  Float_t TA_TO_WALL =  7628 - 4016;
  Float_t OFFSET_FROM_CENTER_AGATA = 0; 
  LightLYCCAVertexBuilder_1::SetTA_Wall(OFFSET_FROM_CENTER_AGATA, TA_TO_WALL);//input manually for the moment. TODO:from parameter files.
        SetVertex(fLyccaData->Pos_target_x2,fLyccaData->Pos_target_y2,fZTDSSDOffset,
              fLyccaData->Pos_deltaX2,fLyccaData->Pos_deltaY2,fZTa_Wall,
              fMeanBeta);
  LightLYCCAVertexBuilder_1::SetPosWall(fLyccaData->w_DSSD_x, fLyccaData->w_DSSD_y, TA_TO_WALL);
    

}

/* method to unpack all in Go4 
void TSPEUnpackProc::GeneralUnpacker(TSPEUnpackEvent* tgt)
{
        
        tgt->SetValid(kFALSE);  // by default output event rejected
        
        tgt->n_tracked_gammas = 0;
        
        // Unpack data structure for non go4 dependant librairy
        // The pointer (public field) of the structure has to be copy/link with 
        // the one from the TSPEUnpackEvent *tgt.
        //  UnpackData *data_unpack = new UnpackData;
        
   TGo4MbsEvent *fInput = dynamic_cast<TGo4MbsEvent*> (GetInputEvent());
   if (fInput==0) return;
        
   Int_t qLength  = fInput->GetDlen()   ;
   Int_t qType    = fInput->GetType()   ;
   Int_t qSubType = fInput->GetSubtype();
   Int_t qDummy   = fInput->GetDummy()  ;
   Int_t qTrigger = fInput->GetTrigger();
   Int_t qEventNr = fInput->GetCount()  ;
        
   if( ! fUnpacker->CheckEventHeader(qLength, qType, qSubType, 
                                     qDummy, qTrigger, qEventNr,
                                     tgt) ) return ;  
        
        //  Event OK, now assign pointer to local subevent header! 
        fInput->ResetIterator();
        TGo4MbsSubEvent *psubevt = 0;
        
        //  fInput->PrintEvent();
        
   while ((psubevt=fInput->NextSubEvent())!= 0) { // start subevents loop
      Int_t subEventType = psubevt->GetType();
      Int_t subEventSubType = psubevt->GetSubtype();
      Int_t *pData = psubevt->GetDataField();
      Int_t lenMax = (psubevt->GetDlen()-2)/2; // Count how many words we have to decode
      Int_t procId = psubevt->GetProcid();
      Int_t controlId = psubevt->GetControl();
                
      //Unpack the sub-event, if successful fill the histograms
      fUnpacker->UnpackSubevent(subEventType,subEventSubType,
                                lenMax, procId, controlId, qTrigger, 
                                pData, 
                                tgt) ;
                
   };  // end subevents loop
        
   FillHistograms(qTrigger, tgt);
   
   tgt->SetValid(kTRUE); // accept event    
}
*/
/*
void get_position(Int_t* event_data, s_vehe* event_header , char* option, Float_t& posX, Float_t& posY, Float_t& multiX,Float_t& multiY,Float_t& maxEX, Float_t& maxEY)
{
        bool DSSDUseSubPixelAlgorithm;
        if (option == "sub_pixel_algo")  DSSDUseSubPixelAlgorithm = true;
        else                             DSSDUseSubPixelAlgorithm = false;
        
        Int_t raw_vme12[3][32];             // LYCCA target
        
        for (int j=0;j<32;j++) for (int i=0;i<3;i++) raw_vme12[i][j]=-1;
        int result = 0;
        Int_t trigNum = event_header->i_trigger;
        
        //Get data pointeur of subevent from the data pointeur of event (MBS API)
        //proper cast.
        s_ves10_1 *subevent_header = 0;
        INTS4 *sub_evt_data = 0;
        INTS4 length = 0;  
        Int_t procID  = 0; 
        Int_t controlID = 0;
        int sub_event_nb = 0;
        
        // Get subevent 9
        sub_event_nb = 8; //the 9th subevent in the dataflow -> LYCCA procID90
        result = f_evt_get_subevent((s_ve10_1*)(event_header), sub_event_nb, (INTS4**)&subevent_header, (INTS4**)&sub_evt_data, &length);
        
        if((trigNum==2)||(trigNum==3)||(trigNum==4)||(trigNum==5)||(trigNum==7)) { 
                procID   = subevent_header->i_procid;
                controlID= subevent_header->h_control;
                if (result==GETEVT__SUCCESS && procID==90 && (controlID == 20 || controlID == 21)){
                        GetRaw_target(sub_evt_data,length,procID,raw_vme12);  }
        }
        
*/