RancLegnaroWatchers.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 "RancLegnaroWatchers.h"

#ifndef _MetaWatchers
#include "MetaWatchers.h"
#endif

#include "TMath.h"

ClassImp(RancLegnaroWatcher);

RancLegnaroWatcher::RancLegnaroWatcher(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir): 
        WatcherWithTag(name,title,sp_dir,tag_dir), 
        fWhichRanc(1u),
        fFrame(0x0)
{
} 

RancLegnaroWatcher::~RancLegnaroWatcher()
{
}
        
Bool_t RancLegnaroWatcher::SetTrigger( ADF::DFTrigger *trigger ) 
{
        if ( Watcher::GetFromTrigger(trigger, "data:ranc0", fFrame) ) { 
                fWhichRanc = 0u; 
                return true; 
        }
        else return Watcher::GetFromTrigger(trigger, "data:ranc1", fFrame);
}

void RancLegnaroWatcher::Exec(Option_t */*option*/) 
{       
        if ( gDebug > 3 ) 
                fLog << info << "RancLegnaroWatcher::Exec is called 1 \n";

        // be sure the frame has been set properly
        if ( fFrame == 0x0 || !fFrame->IsValid() ) 
                { SetLastExecStatus(1); return; }

        // get the data part of the frame
        UInt_t nbbytes = fFrame->GetFrame()->Read() / 4u; 
        
        // extract the arrar from the frame
        const BufferIO *buf = fFrame->GetFrame()->GetRealBuffer();
        buf->SetOffset();       
        
        switch ( fWhichRanc ) {
                case 0u:
                        buf->Export((Char_t*)rawBufI, gMaxSlots*gMaxChannels*sizeof(UInt_t));
                        lenrawBuf = gMaxSlots*gMaxChannels;     
                        for (UInt_t i = 0u; i < gMaxSlots*gMaxChannels ; i++) {
                                rawBuf[i] = Float_t(rawBufI[i]);
                        }
                        break;
                case 1u:
                        buf->Export((Char_t*)&lenrawBuf, sizeof(UInt_t));
                        if ( lenrawBuf < nbbytes && lenrawBuf < gMaxSlots*gMaxChannels+gExtraSize ) 
                                buf->Export((Char_t*)rawBuf, lenrawBuf*sizeof(Float_t));
                        else 
                                lenrawBuf = 0; // wrong reading of the frame
                        break;                  
                default:
                        break;
        }
}

// DisplayRancLegnaro Watcher //////////////////////////////////////////////////////////////

ClassImp(DisplayRancLegnaro);

DisplayRancLegnaro::DisplayRancLegnaro(const char *name, const char *title,TDirectory *sp_dir, TDirectory *tag_dir): 
        RancLegnaroWatcher(name,title,sp_dir,tag_dir), 
        fLength(0x0),
        fAllSlots(),
        fListAdded()
{
        fLength = MakeTH1<TH1F>("Length","Length Of the DisplayRancLegnaro buffer",100,0,200);
        fAllSlots = MakeTH2<TH2F>("AllSlots","Distribution per slot",gMaxSlots*gMaxChannels+10,0,gMaxSlots*gMaxChannels+10,1024,0,4096);
} 

/*
DisplayRancLegnaro::~DisplayRancLegnaro()
{
}
*/

void DisplayRancLegnaro::DoCanvas(TCanvas * /*c*/, Option_t *o)
{
//      static UShort_t nb_pad_x = 3, nb_pad_y = 3;
        
        TString option = o;
        if ( option == "" ) {
                fAllSlots->Draw();
        }
        if ( option == "mat" ) {
        }       
}

void DisplayRancLegnaro::AddMatrix(UShort_t ch1, UShort_t ch2, UShort_t dch1, UShort_t dch2, Int_t binx, Double_t xmin, Double_t xmax, Int_t biny, Double_t ymin, Double_t ymax)
{
        if ( !(ch1 < gMaxSlots*gMaxChannels+gExtraSize) )
                return;
        if ( !(ch2 < gMaxSlots*gMaxChannels+gExtraSize) )
                return;
        
        Int_t ech1 = TMath::Min( ch1 + dch1, gMaxSlots*gMaxChannels+gExtraSize ) ;
        Int_t ech2 = TMath::Min( ch2 + dch2, gMaxSlots*gMaxChannels+gExtraSize ) ;
        
        // check some consistencies

        for (Int_t ix = ch1; ix < ech1; ix++) {
                for (Int_t jx = ch2; jx < ech2; jx++) {
                        
                        // check if already there 
                        Bool_t to_add = true;

                        for (size_t i = 0; i < fListAdded.size(); i++) {
                                if ( fListAdded[i].first.first == ix && fListAdded[i].first.second == jx )
                                        { to_add = false; break;}
                                if ( fListAdded[i].first.first == jx && fListAdded[i].first.second == ix )
                                        { to_add = false; break;}                                
                        }
                        if ( to_add ) {
                                std::pair < std::pair<UShort_t, UShort_t> , TH2F *> bidim;
                                bidim.first.first  = ix;
                                bidim.first.second = jx;
                                
                                TString tmp = Form("DisplayRanc_%d_%d",ix,jx);
                                bidim.second  = MakeTH2<TH2F>(tmp.Data(),tmp.Data(),binx,xmin,xmax,biny,ymin,ymax);
                                                                
                                fListAdded.push_back( bidim );
                        }
                }
        }
}


void DisplayRancLegnaro::Exec(Option_t *option) 
{
        if ( gDebug > 3 ) 
                fLog << info << "DisplayRancLegnaro::Exec is called \n";
        
        // fill the array of floats, check if something goes wrong
        SetLastExecStatus(0);
        RancLegnaroWatcher::Exec(option);
        if ( GetLastExecStatus() != 0 ) 
                return;
        
        // fill the specta
        fLength->Fill(lenrawBuf);
        
        // lenrawBuf set to 0 in case it is not read properly in the ancillary Frame
        if ( lenrawBuf == 0u )
                return;

        for (UInt_t i = 0u; i < lenrawBuf; i++  ) 
                fAllSlots->Fill(i,rawBuf[i]);   
        
        for (size_t i = 0; i < fListAdded.size(); i++) {
                if ( !(fListAdded[i].first.first < lenrawBuf) )
                        continue;
                if ( !(fListAdded[i].first.second < lenrawBuf) )
                        continue;               
                
                fListAdded[i].second->Fill(rawBuf[fListAdded[i].first.first],rawBuf[fListAdded[i].first.second]);
        }
}

// ReadAncVertex Watcher //////////////////////////////////////////////////////////////

/*
ClassImp(ReadAncVertex);

ReadAncVertex::ReadAncVertex(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir) : 
        RancLegnaroWatcher(name,title,sp_dir,tag_dir),
        VertexBuilder()
{
        fVertexFrame = MainFrameFactory::theMainFactory().
                NewSharedFrame( FactoryItem("Agata","meta:vertex",Version(0,0)), FactoryItem("Agata","meta:vertex",Version(1,1)) );
        
        fIsToBeDeleted = true; 
}

void ReadAncVertex::Exec(Option_t *option) 
{
        Double_t x, y, z, Dx, Dy, Dz, beta;

        SetLastExecStatus(0);
        RancLegnaroWatcher::Exec(option);
        if ( GetLastExecStatus() != 0 ) 
                return;
        
        if ( lenrawBuf < 6 )
                return;
        
        x  = rawBuf[lenrawBuf-6 + 0];
        y  = rawBuf[lenrawBuf-6 + 1];
        z  = rawBuf[lenrawBuf-6 + 2];
        x = y = z = 0;
        Dx = rawBuf[lenrawBuf-3 + 0];
        Dy = rawBuf[lenrawBuf-3 + 1];
        Dz = rawBuf[lenrawBuf-3 + 2];
        
        beta = TMath::Sqrt(Dx*Dx + Dy*Dy + Dz*Dz);
        
//      if ( beta > 0.0 )
//              cout << " -- " << Dx << " " << Dy << " " << Dz << endl;
                
        // fill the current vertex
        VertexInterface *gdata = GetVertex();
        gdata->SetPosition(x,y,z);
        gdata->SetDirection(Dx,Dy,Dz);  
        gdata->SetBeta(beta);
}

*/