GlobalFieldProcessor.h

#ifndef GLOBALFIELDPROCESSOR_H
#define GLOBALFIELDPROCESSOR_H 1

#include <string>
#include <map>

// CLHEP
#include <CLHEP/Matrix/Vector.h>
#include <CLHEP/Vector/ThreeVector.h>

// LCCD
#include <lccd/IConditionsChangeListener.hh>

// Marlin
#include "Field.h"
#include "MagneticField.h"
#include "marlin/Processor.h"

namespace EVENT {

        class LCCollection;
        class LCEvent;
        class LCGenericObject;
        class LCRunHeader;
}

namespace marlintpc {

class MagneticField;

class GlobalFieldProcessor: public marlin::Processor {

public:

        GlobalFieldProcessor();

        virtual ~GlobalFieldProcessor();

        virtual Processor* newProcessor();

        virtual void init();

        virtual void processRunHeader(lcio::LCRunHeader* run );

        virtual void processEvent(lcio::LCEvent * evt );

        virtual void check(lcio::LCEvent * evt );

        virtual void end();

        bool register_field( Field* );

        CLHEP::HepVector get_global_magnetic_field( const CLHEP::HepVector& x ) const;

        CLHEP::Hep3Vector get_global_magnetic_field( const CLHEP::Hep3Vector& x ) const;

        CLHEP::Hep3Vector get_global_magnetic_field_error( ) const;

        CLHEP::HepVector get_global_electric_field( const CLHEP::HepVector& x ) const;

        CLHEP::Hep3Vector get_global_electric_field( const CLHEP::Hep3Vector& x ) const;

        CLHEP::Hep3Vector get_global_electric_field_error( ) const;

        static GlobalFieldProcessor &get_instance();

        double get_main_crossing_angle() const;

protected:

        class FieldNotifier: public lccd::IConditionsChangeListener {

        public:

                FieldNotifier( Field& field );

                virtual void conditionsChanged( lcio::LCCollection* col );

                private:

                        Field &_field;
        };

        class CoilPositionNotifier: public lccd::IConditionsChangeListener {

        public:

                CoilPositionNotifier( std::vector<Field*> _active_magnetic_fields );

                virtual void conditionsChanged( lcio::LCCollection* col );

        private:

                std::vector<MagneticField*> _magnetic_fields;

        };

private:
        
        bool _use_gear_bfield;

        #ifdef USE_CGA

        bool _use_cga_fields;
        #endif // USE_CGA

        std::vector<std::string> _input_magnetic_fields;

        std::vector<std::string> _input_electric_fields;

        static GlobalFieldProcessor *_instance;

        std::map<std::string, Field*> _field_by_typename;

        std::vector<Field*> _active_magnetic_fields;

        std::vector<Field*> _active_electric_fields;

        std::vector<FieldNotifier*> _field_notifiers;

        double _main_crossing_angle;

        std::string _coil_position_collection;

        CoilPositionNotifier* _coil_position_notifier;

};

} // namespace marlintpc

#endif // GLOBALFIELDPROCESSOR_H