//
// $Id: GtrFieldPkg.cpp,v 1.1 2001/10/24 14:46:58 greenlee Exp $
//
// File: GtrFieldPkg.cpp
// Purpose: Implementation for GtrFieldPkg package class.
// Created: 11-Oct-2001   Herb Greenlee
//
// $Revision: 1.1 $
//
//

// Include files

#include <iostream>
#include <vector>
#include <string>
#include "framework/Registry.hpp"
#include "gtrbase/GtrFieldPkg.hpp"
#include "rcp/RCP.hpp"
#include "mag_field/ConstantMagneticField.hpp"
#include "mag_field/MCField.hpp"
#include "mag_field/ToscaField.hpp"
#include "mag_field/MagFieldMgr.hpp"
#include "mag_field_config/MagRegistrar.hpp"
#include "objstream/ObjTable.hpp"
#include "trfbase/ObjMagFieldPtr.h"
#include "trfbase/ObjDoublePtr.h"
#include "config_base/xNotifier.hpp"
#include "config_base/xEvent.hpp"
#include "config_base/xEventDispatcher.hpp"
#include "framework/Testing.hpp"

using std::vector;
using std::cerr;
using std::endl;
using std::string;
using fwk::Package;
using fwk::Context;
using edm::RCP;
using cfg::xNotifier;
using cfg::xEvent;
using cfg::xEventList;
using cfg::xEventDispatcher;

// Framework registration

FWK_REGISTRY_IMPL(GtrFieldPkg, "$Name:  $")

// Instantiate magnetic field configurator (same as linking with 
// RegistryMagConfigurator.o).

static MagRegistrar reg;

// Static instance.

GtrFieldPkg* GtrFieldPkg::_instance = 0;

//**********************************************************************

// Constructor

GtrFieldPkg::GtrFieldPkg(Context* context) : 
  Package(context),
  xNotifier("mag_field:*")
  //
  // Purpose: Constructor
  //
  // Arguements: context   - Context variable.  Must be passed to all
  //                         base class constructors.
  //
{
  // Crash if this package has already been initialized.

  if(_instance != 0) {
    cerr << "Attempt to create more than one instance of GtrFieldPkg." << endl;
    abort();
    return;
  }
  _instance = this;

  // Register with xEventDispatcher.

  xEventDispatcher* ped = xEventDispatcher::get_instance();
  ped->add_notifier(this);

  // Extract rcp parameters.

  RCP& rcp = packageRCP();
  string type = rcp.getString("default_field_type");
  double param1 = rcp.getDouble("default_field_param1");
  double param2 = rcp.getDouble("default_field_param2");
  _use_default_field = rcp.getBool("use_default_field");
  _use_default_field_if_zero = rcp.getBool("use_default_field_if_zero");

  // Construct default magnetic field, if needed.

  if(_use_default_field || _use_default_field_if_zero) {
    if(type == "constant")
      _bfield_map_default = new ConstantMagneticField(param1);
    else if(type == "mc")
      _bfield_map_default = new MCField(param1, param2);
    else if(type == "tosca")
      _bfield_map_default = new ToscaField(param1, param2);
    else {
      cerr << "GtrFieldPkg: Unknown field type: " << type << endl;
      abort();
    }
    if(_use_default_field)
      _bfield_map_actual_p = new ObjMagField(_bfield_map_default);
  }

  // Get configured magnetic field, if needed.

  if(!_use_default_field) {
    MagFieldMgr* mgr = MagFieldMgr::get_instance();
    _bfield_map_config = mgr->get_field();
    _bfield_map_actual_p = new ObjMagField(_bfield_map_config);
  }

  // Fill remaining magnetic field  attributes.

  _bfield_map_p = new ObjMagField;
  _bfield_actual_p = new ObjDouble(0.);
  _bfield_p = new ObjDouble(0.);
  refresh();

  // Add parameters to ObjTable.

  ObjTable::add_object("bfield_map", ObjMagFieldPtr(_bfield_map_p));
  ObjTable::add_object("bfield_map_actual", 
		       ObjMagFieldPtr(_bfield_map_actual_p));
  ObjTable::add_object("bfield", ObjDoublePtr(_bfield_p));
  ObjTable::add_object("bfield_actual", ObjDoublePtr(_bfield_actual_p));

}

//**********************************************************************

// Destructor

GtrFieldPkg::~GtrFieldPkg()
  //
  // Purpose: Destructor
  //
{}

//**********************************************************************

void GtrFieldPkg::initialize()
{
  if(_instance == 0) {
    GtrFieldPkg* p = 0;
    makePackage(p, "gtrbase", "GtrFieldPkg");
    assert(p != 0);
    assert(p == _instance);
  }
  assert(_instance != 0);
}

//**********************************************************************

void GtrFieldPkg::wake_up(const cfg::xEventList& events)
{
  bool mag_field = false;
  for(xEventList::const_iterator i = events.begin(); i != events.end(); ++i) {
    const xEvent& evt = **i;
    mag_field = (evt.get_name().substr(0, 10) == "mag_field:");
    if(mag_field)
      break;
  }
  if(mag_field)
    refresh();
}

//**********************************************************************

// Refresh global objects.

void GtrFieldPkg::refresh()
{
  // Fill magnetic field pointers.

  CartesianPoint origin(0., 0., 0.);
  SpacePointVector bf = (*_bfield_map_actual_p)->field(origin);
  *_bfield_actual_p = bf.v_z();
  if(_use_default_field_if_zero && (*_bfield_actual_p)() == 0) {
    *_bfield_map_p = _bfield_map_default;
    SpacePointVector bf = (*_bfield_map_p)->field(origin);
    *_bfield_p = bf.v_z();
  }
  else {
    *_bfield_map_p = *_bfield_map_actual_p;
    *_bfield_p = *_bfield_actual_p;
  }
}

//**********************************************************************