ExTracking.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 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 "ExTracking.h"
#include "TrackedFrame.h"

#include "AgataGeometryTransformer.h"
#include "TSystem.h"

using namespace ADF; 
using namespace Gw; 

// local namespace to this file only
namespace { 
        // version number of this Tracking
        /*
                allow to set version number of the current tracking
        */
        Version gMyVersion(0,0);
        
        // Ex on how to set restriction on triggers for a given set of tracked frame
        // In case the current version # of the given frame on the data flow is not compatible with the analysis, the trigger becomes not running.
        // in this case the major version number of the tracked frame should be lower or equal that My analysis Version (gMyVersion)
        /*
        Bool_t AllowTrackedFrame(const FactoryItem & item_from, const FactoryItem &item_to) {
                if ( item_to.GetVersion().GetMajor() == gMyVersion.GetMajor() )
                        return true;
                return false;
        }
        */
        AgataGeometryTransformer *fTrans;
}

ExTracking::ExTracking() : 
        NarvalFilter(), 
        fTrigger(0x0),
        fAllocatedPSAFrame(),
        fCurrentPSA()
{       
        Log.GetProcessName() = "ExTracking"; GetFrameIO().SetName("ExTracking");
}

ExTracking::~ExTracking() 
{  
        // in principle not needed ... just in case reset has not been called by narval
        UInt_t error = 0u; process_reset(&error) ; 
} 

UInt_t ExTracking::SetInput()
{
        // clear previous event
        fCurrentPSA.clear();
        
        SharedFP *psa_frames = fTrigger->GetInputSharedFP(1); SharedFP *track_frame = fTrigger->GetOutputSharedFP();
        // check the event:data:psa frame exists ... in case the trigger is lazy
        if ( psa_frames == 0x0 ) {
                return 0u;              
        }
        else {
                if ( !psa_frames->IsValid() ) 
                        return 0u;
        }
        track_frame->GetFrame()->Reset();
        
        //
        GammaTrackedInterface *data_track =     
                GetDataPointer<GammaTrackedInterface>(track_frame); 

        // Scan the event:psa frame to extract all the PSAInterface
        UInt_t nb_psa_frames = psa_frames->GetFrame()->Scan(); SharedFP *psa;
                
        for (UInt_t i = 0u; i < nb_psa_frames; i++) {
                if ( !(i < fAllocatedPSAFrame.size()) ) { // a new frame has to be allocated, aware of re configuration so the trigger utility is used for that
                        psa = fTrigger->AddUtility("data:psa",ConfAgent::theGlobalAgent());
                        if ( psa == 0x0 ) {
                                Log << error << " cannot allocate more that " << fAllocatedPSAFrame.size() << dolog;
                                return fCurrentPSA.size();
                        }
                        else { fAllocatedPSAFrame.push_back(psa); }                     
                }
                psa = fAllocatedPSAFrame[i];

                PSAInterface *data_psa =
                        fTrigger->GetSubDataFrom<PSAInterface>(1,i,psa,false);
                if ( data_psa )
                        fCurrentPSA.push_back(data_psa);
        }
        //for all hits in the psa frames, apply transformation local -> global
        for (UInt_t ipsa = 0u; ipsa < fCurrentPSA.size(); ipsa++) {
                
                TrackedHit *atracked_hit = data_track->NewGamma(); atracked_hit->SetE(fCurrentPSA[ipsa]->GetE()); 
                
                for (UShort_t ihit = 0u; ihit < fCurrentPSA[ipsa]->GetNbHits(); ihit++) {
                        //
                        Double_t xLocal, yLocal, zLocal, xGlobal, yGlobal, zGlobal;     Double_t max_e = 0.0; 
                        
                        fCurrentPSA[ipsa]->GetHit(ihit)->GetXYZ(xLocal, yLocal, zLocal);
                        fTrans->Local2Global(fCurrentPSA[ipsa]->GetUID(), xLocal, yLocal, zLocal, xGlobal, yGlobal, zGlobal);  
                         
                        if ( fCurrentPSA[ipsa]->GetHit(ihit)->GetE() > max_e ) {                                
                                max_e = fCurrentPSA[ipsa]->GetHit(ihit)->GetE();
                                atracked_hit->SetXYZ(xGlobal, yGlobal, zGlobal);
                        }          
                }
        }
        // return the # of data interface for that event
        return 0u;
}


void ExTracking::process_config (const Char_t *directory_path, UInt_t *error_code)
{
        // In case your algorithm needs to initiate globals, it should be done here
        
        // Globals for ADF are read from ADF.conf (should be in your algo path !!)
        NarvalInterface::process_config(directory_path,error_code);
  
        if ( (*error_code) == 0u ) { // now init your stuff
        
                // here could come the reading of a file in which are stored the 
                // units (position,energy) you are working with i.e. modifications
                // of UnitPosition UnitEnergy defined in the base class AlgoDummy
                // + ....
                // NarvalInterface (through process_config(), so don't forget it) 
                // keeps the name of the directory_path. To get it back: GetConfPath()
        }
}

UInt_t ExTracking::Process()
{
        return 0u;
}

UInt_t ExTracking::SetOutput()
{       
        Frame *trackframe = fTrigger->GetOutputSharedFP()->GetFrame(); Frame *eventdataframe = fTrigger->GetInputSharedFP(1)->GetFrame();
        
        ((AgataKey *)trackframe->GetKey())->SetEventNumber( ((AgataKey *)eventdataframe->GetKey())->GetEventNumber() );
        ((AgataKey *)trackframe->GetKey())->SetTimeStamp( ((AgataKey *)eventdataframe->GetKey())->GetTimeStamp() );
        
        trackframe->Write();
        
        /*
        const GammaTrackedInterface *data =     
                GetCstDataPointer<GammaTrackedInterface>(trackframe); 
                
        UInt_t fold = data->GetNbGamma();
        for (UShort_t i = 0u; i < fold; i++) {
                
                const TrackedHit *gamma1 = data->GetGamma(i);
                cout << gamma1->GetX() << " " << gamma1->GetY() << " " << gamma1->GetZ() << endl;

        }
        */
        
        return 0u;      
}

UInt_t ExTracking::ProcessBlock(ADF::FrameBlock &in, ADF::FrameBlock &out)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_block");

        // attach the input/output buffer to the FrameIO system
        GetFrameIO().Attach(&in,&out);
                
        // start the processing
        UInt_t error_code = 0u;
        while ( GetFrameIO().Notify() ) { // process the input 
                
                if ( ! (SetInput() == 0u && Process() == 0u && SetOutput() == 0u) )  
                        { error_code =  1u; break; } 
                else {
                        if ( !GetFrameIO().Record() )
                                { error_code =  2u; break; }
                }
        }
        if ( error_code == 1u ) {
                Log << error 
                    << "During processing : SetInput -> Process -> SetOuput() " << nline;
        }       
        if ( error_code == 2u ) {
                Log << error 
                        << "During Record() " << nline;
        }       
        GetFrameIO().Detach(&in,&out);
        
        // send messages to the central log
        Log << dolog;
        return error_code;
}             


void ExTracking::process_initialise (UInt_t *error_code)
{
        *error_code = 0; Log.ClearMessage(); Log.SetProcessMethod("process_initialise"); 
        
        /*
         this trigger returns if an event:data frame is found containing en event:data:psa and a data:tracked
         the data tracked is consumed to be replaced by the new one
        */
        fTrigger = AgataFrameTrigger::Build("ExTracking","event:data event:data:psa","data:tracked");
        if ( fTrigger == 0x0 ) {
                Log << warning << "Cannot build trigger ExTracking " << nline ;
                (*error_code) = 1u;
        }
        else {
                // set the data:tracked frame as consumable
//              fTrigger->SetConsumable(2,true);

                Log << info << "ExTracking has been registered " << nline ;
                
                // once fully defined, register the trigger 
                GetFrameIO().Register(fTrigger);
                GetFrameIO().SetStatus(BaseFrameIO::kIdle);             
        }
        
        fTrans = new AgataGeometryTransformer(); Bool_t ok = false;

        if ( gSystem->AccessPathName("CrystalPositionLookUpTable") ) { // does not exist
                if ( gSystem->AccessPathName("CrystalPositionLookUpTable.dat") ) {
                        Log << error << " CrystalPositionLookUpTable required " << nline; 
                }
                else {
                        Log << info << " Ge positions extracted from CrystalPositionLookUpTable.dat " << nline; 
                        fTrans->ReadTransformations("CrystalPositionLookUpTable.dat");
                        
                        ok = true;
                }
        }
        else {
                Log << info << " Ge positions extracted from CrystalPositionLookUpTable.dat " << nline; 
                fTrans->ReadTransformations("CrystalPositionLookUpTable");
                
                ok = true;
        }
        if ( ! ok )
                (*error_code) = 1u; 
        
        Log << dolog;           
}


void ExTracking::process_reset (UInt_t * /*error_code*/)
{
        Log.SetProcessMethod("process_reset"); 
                
        GetFrameIO().Print( Log() );

        Log << dolog;
}