WaveformScalarAnalyze.hpp

 
//
// $Id: hpp,v 1.0 2000/01/01 00:00:01 werner Exp $
//
// $Log: hpp,v $
// Created 2011/02/04 11:39:53  mritter
// Initial version
//
//
#ifndef __WAVEFORMSCALARANALYZE
 
#define __WAVEFORMSCALARANALYZE
 
#include <string>
#include <bone/FishField.hpp>
#include <elementary/eagle/PhysicalSpace.hpp>
 
 
namespace Waveform
{
 
// classes as trait switches carrying is name as static string
struct WaveTimeOfMaximum{ static const std::string Name; };
const std::string WaveTimeOfMaximum::Name = "WaveTimeOfMaximum";
 
struct WaveMaximum{ static const std::string Name; };
const std::string WaveMaximum::Name = "WaveMaximum";
 
struct WaveSize{static const std::string Name; };
const std::string WaveSize::Name = "WaveSize";
 
struct WaveIntegral{static const std::string Name;};
const std::string WaveIntegral::Name = "WaveIntegral";
 
 
// do analysis per fragmented as trait function
template<class TT> 
bool computeScalarArray( Fiber::MultiArray<2, unsigned short>&Waveform, MemCore::RefPtr<Fiber::Field>&ResultField, 
                         const MemCore::RefPtr<Fiber::FragmentID>&f )
{
        puts("WaveformScalarAnalyze::getScalarArray() Do nothing getScalarArray");
        return false;
}
 
 
 
template<>
bool computeScalarArray<WaveTimeOfMaximum>( Fiber::MultiArray<2, unsigned short>&Waveform, 
                                            MemCore::RefPtr<Fiber::Field>&ResultField, 
                                            const MemCore::RefPtr<Fiber::FragmentID>&f )
{
#ifdef VERBOSE
        puts("WaveformScalarAnalyze::computeScalarArray<WaveTimeOfMaximum>() WaveTimeMaximum");
#endif 
        // get dimensions of waveforms 
       Fiber::MultiIndex<2> dims; 
               dims = Waveform.Size(); 
 
       size_t wavesize = dims[0]; 
       size_t number_of_waveforms =  dims[1];
 
#ifdef VERBOSE 
       std::cout << "WaveformScalarAnalyze::computeScalarArray<WaveTimeOfMaximum>() Dims: " << dims[0] << "x" << dims[1] << std::endl;
#endif 
 
       // create new Array for time values at maximum
       MemCore::RefPtr<Fiber::MemArray<1, unsigned short> > Maximums = new Fiber::MemArray<1, unsigned short>( number_of_waveforms ); 
       Fiber::MultiArray<1, unsigned short>&MaxArr = *Maximums; 
 
               // compute maximum and location of maximum (time = int * 500 pico-sec)
               for( size_t i = 0; i < number_of_waveforms; i++  )
               {
               unsigned short max = 0; 
               unsigned short max_pos = 0;
 
                       for( size_t j = 0; j < wavesize; j++ )
                               if( max <  Waveform[i][j] )
                               {
                                       max = Waveform[i][j]; 
                                       max_pos = j;
                               } 
                       MaxArr[i] = max_pos; 
               } 
 
#ifdef VERBOSE 
               if( f )
                       std::cout << "storing in " << f->Name() << std::endl;
#endif  
 
               // store array data in field
               ResultField->setPersistentData( Maximums, f );
 
        return true;
}
 
 
 
 
template<>
bool computeScalarArray<WaveMaximum>( Fiber::MultiArray<2, unsigned short>&Waveform, 
                                      MemCore::RefPtr<Fiber::Field>&ResultField, 
                                      const MemCore::RefPtr<Fiber::FragmentID>&f )
{
#ifdef VERBOSE
        puts("WaveformScalarAnalyze::getScalarArray()<WaveMaximum>WaveTimeMaximum");
#endif 
 
       Fiber::MultiIndex<2> dims; 
               dims = Waveform.Size(); 
 
       size_t wavesize = dims[0]; 
       size_t number_of_waveforms =  dims[1];
 
        MemCore::RefPtr<Fiber::MemArray<1, unsigned short> > Maximums = new Fiber::MemArray<1, unsigned short>( number_of_waveforms ); 
        Fiber::MultiArray<1, unsigned short>&MaxArr = *Maximums; 
 
        Fiber::MultiIndex<2> mi;
 
               for( size_t i = 0; i < number_of_waveforms; i++  )
               {
               unsigned short max = 0; 
 
                       for( size_t j = 0; j < wavesize; j++ )
                       {
                               mi = j,i;   
                               if( max <  Waveform[mi] )
                                       max = Waveform[mi]; 
                       } 
                       MaxArr[i] = max;
               } 
 
               ResultField->setPersistentData( Maximums, f );
 
        return true;
}
 
// Detecting size of waveform by first occurance of !0 in the waveform array iterated from the back. 
template<>
bool computeScalarArray<WaveSize>( Fiber::MultiArray<2, unsigned short>&Waveform, 
                                      MemCore::RefPtr<Fiber::Field>&ResultField, 
                                      const MemCore::RefPtr<Fiber::FragmentID>&f )
{
#ifdef VERBOSE
        puts("WaveformScalarAnalyze::getScalarArray()<WaveSize>WaveTimeMaximum");
#endif 
       Fiber::MultiIndex<2> dims; 
               dims = Waveform.Size(); 
 
#ifdef VERBOSE 
               std::cout << "WaveformScalarAnalyze::computeScalarArray<WaveTimeOfMaximum>() Dims: " << dims[0] << "x" << dims[1] << std::endl; 
#endif 
 
       size_t wavesize = dims[0]; 
       size_t number_of_waveforms =  dims[1];
 
        MemCore::RefPtr<Fiber::MemArray<1, unsigned short> > SizeArr = new Fiber::MemArray<1, unsigned short>( number_of_waveforms ); 
        Fiber::MultiArray<1, unsigned short>&SizeValue = *SizeArr; 
 
        Fiber::MultiIndex<2> mi; 
 
 
        for( size_t i = 0; i < number_of_waveforms; i++  ) 
                for( size_t j = wavesize - 1; j >= 0; j-- )
                {
                        mi = j,i; 
                        if( Waveform[mi] != 0 )
                        {
                                SizeValue[i] =  j + 1; 
//                              std::cout << " : " << SizeValue[i] << std::endl; 
                                break; 
                        }
                } 
 
        ResultField->setPersistentData( SizeArr, f );
 
        return true;
}
 
 
 
 
template<>
bool computeScalarArray<WaveIntegral>( Fiber::MultiArray<2, unsigned short>&Waveform, 
                                      MemCore::RefPtr<Fiber::Field>&ResultField, 
                                      const MemCore::RefPtr<Fiber::FragmentID>&f )
{
#ifdef VERBOSE
        puts("WaveformScalarAnalyze::computeScalarArray<WaveIntegral>()");
#endif 
 
       Fiber::MultiIndex<2> dims; 
               dims = Waveform.Size(); 
 
       size_t wavesize = dims[0]; 
       size_t number_of_waveforms =  dims[1];
 
        MemCore::RefPtr<Fiber::MemArray<1, unsigned short> > IntegralArr = new Fiber::MemArray<1, unsigned short>( number_of_waveforms ); 
        Fiber::MultiArray<1, unsigned short>&IntegralValue = *IntegralArr; 
 
        Fiber::MultiIndex<2> mi;
 
               for( size_t i = 0; i < number_of_waveforms; i++  )
               {
 
               unsigned short sum = 0; 
 
                       for( size_t j = 0; j < wavesize; j++ )
                       {
                               mi = j,i; 
                               sum += Waveform[mi];
                       }
                       IntegralValue[i] = sum;
               } 
 
               ResultField->setPersistentData( IntegralArr, f );
 
        return true;
}
 
 
}
#endif