GANIL/EventWatchers.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   Copyright (C) 2010 by Christian Finck                                 * 
 *   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.             *
 ***************************************************************************/

// Watcher definition
#include "EventWatchers.h"
#include "AgataKeyFactory.h"
#include "PSAFrame.h"

using namespace ADF;

ClassImp(EventWatcher);


Bool_t EventWatcher::SetTrigger( ADF::DFTrigger *trigger ) 
{
        return Watcher::GetFromTrigger(trigger, "event:data", fFrame);  
}

ClassImp(TSCoinc);

Bool_t TSCoinc::SetTrigger( ADF::DFTrigger *trigger ) 
{
        Bool_t ok = false; TString f_type; TH1F *h;
        
        // check if this trigger is not a zombie
        if ( ! Watcher::SetTrigger(trigger) )
                return ok;
        
        // check first that the main frame is a composite frame
        // if yes set fFrame to it
        if( ! GetTrigger()->GetInputFrame(0u)->IsComposite() )
                 return ok;
        else { 
                fFrame = GetTrigger()->GetInputSharedFP(0u); 
                f_type = fFrame->GetFrame()->GetSignature().GetItemName();
                
                h = MakeTH1<TH1F>(Form("DiffCTS_%s",f_type.Data()),"Time between two consecutive events",1000,0, 10000000);             
                fCoinc->AddAt( h , 0 );
        }

        // loop on the trigger and define a histogram associated to each sub frame
        for(UInt_t which = 1u; which < GetTrigger()->GetNbInputFrame(); which++){
                
                Frame *f = GetTrigger()->GetInputFrame(which);
                if ( f == 0x0 )
                        continue;

                // to get the type of frame, used to set the histogram's name
                f_type = f->GetSignature().GetItemName();

        h = MakeTH1<TH1F>(Form("TS_%s",f_type.Data()),"TS Coinc in a composite Frame",500,0,500);
                fCoinc->AddAt(h,which);
                TagOn(h);
        }
        if ( dynamic_cast<AgataFrameTrigger *> (GetTrigger())) {
                fPSAFrame = (dynamic_cast<AgataFrameTrigger *> (GetTrigger()))->AddUtility("data:psa",ConfAgent::theGlobalAgent());
        }
        
        return true;    
}

TSCoinc::TSCoinc(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir) : 
        EventWatcher(name,title,sp_dir,tag_dir), 
        fLastTimeStamp(0UL), 
        fCoinc( new TObjArray() ),
        fCoincPerCrystal(0x0)
{
    fCoincPerCrystal = MakeTH2<TH2F>("CoincPerCrystal","TS Coinc in a composite Frame",180,0,180,500,0,500);
        ;
}

void TSCoinc::DoCanvas(TCanvas *c, Option_t *o)
{
        TString option = o;
        if ( option == "" ) {
        c->Divide(2,2,0.001,0.001);
                
                c->cd(1); 
                if ( fCoinc->At(0) ) 
                        fCoinc->At(0)->Draw();  
                c->cd(2); 
                Bool_t first = true;
                for (Int_t i = 1u;  i < fCoinc->GetSize() ; i++ ) {
        
                        if ( fCoinc->At(i) == 0x0 )
                                continue;
                        
                        if ( first ) {
                                fCoinc->At(i)->Draw();
                                first = false;
                        }
                        else {
                                fCoinc->At(i)->Draw("same");
                        }
                }
        c->cd(3); fCoincPerCrystal->Draw();
        }       
}

void TSCoinc::Exec(Option_t * /*option*/)
{
        if ( fFrame == 0x0 || !fFrame->IsValid() )
                { SetLastExecStatus(1); return; }       
        
        // to get the main key
        AgataKey * mainkey = dynamic_cast<AgataKey *> (fFrame->GetFrame()->GetKey());
        
        // difference between two "consecutive" timestamps
        TH1F *h = dynamic_cast<TH1F*>(fCoinc->At(0));
        if ( h ) 
                h->Fill( mainkey->GetTimeStamp() - fLastTimeStamp );
        fLastTimeStamp = mainkey->GetTimeStamp();

        // loop on subframes and compute the timestamp differences
        for(UInt_t which = 1u; which < GetTrigger()->GetNbInputFrame(); which++){
                
                Frame *f = GetTrigger()->GetInputFrame(which);
                if ( f == 0x0 )
                        continue;
                
                if ( !GetTrigger()->IsIndividualFired() ) // trigger may be with option ! (anti-coincidence) or | (with OR without this frame) for that frame
                        continue;               
                /* another possible, similar test if trigger is not known by the user
                if ( !f->IsValid() ) // 
                        continue;
                */
                AgataKey * subkey = dynamic_cast<AgataKey *> (f->GetKey()); h = dynamic_cast<TH1F*>(fCoinc->At(which));
                if ( h == 0x0 || subkey == 0x0 )
                        continue;               
                
                h->Fill( subkey->GetTimeStamp() - fLastTimeStamp );
                if ( subkey->GetSignature().GetItemName().find("event:data:psa") != string::npos ) { // a composition frame of type event:data:psa
                //      f->Scan();
                        for (UInt_t i = 0u; i < f->GetNbSubFrame(); i++) {
                                f->LinkSubFrame(which,fPSAFrame->GetFrame()); 
                                fPSAFrame->GetFrame()->Read(); 
                                PSAInterface *data = 
                                        GetDataPointer<PSAInterface>(fPSAFrame);
                                UInt_t crysal_id = data->GetUID();
                                
                                AgataKey * subsubkey = dynamic_cast<AgataKey *> (fPSAFrame->GetFrame()->GetKey());
                                fCoincPerCrystal->Fill( crysal_id, subsubkey->GetTimeStamp() - fLastTimeStamp );
                        }
                }
        }       
}