///////////////////////////////////////////////////////////////////////////////
// File: tsim_l1ft.cpp
//
// Purpose:  L1 FT ( CFT, CPS and FPS ) trigger simulation 
//
// Created:     1-Apr-1999: Kin Yip
//           
///////////////////////////////////////////////////////////////////////////////

#include "tsim_l1ft/tsim_l1ft.hpp"
#include "tsim_l1ft/cft_parameters.hpp"
#include "tsim_l1ft/cft_hittrk.hpp"

#include "tsim_l1ft/FPS_L1ClusterChunk.hpp"

#include "unpack_evt/UnpChunkSelector.hpp"
#include "run_config/RunConfig.hpp"

#include "HepTuple/HepNtuple.h"

#include "identifiers/ChunkID.hpp"
#include "identifiers/EnvID.hpp"
#include "identifiers/RCPID.hpp"

#ifndef DEFECT_NO_NAMESPACES
using edm::ChunkID;
using edm::EnvID;
using edm::RCPID;
#endif

using namespace fwk ;
using namespace D0MCH ;
using edm::RCP ;

namespace D0MCH{
  ModuleTypes defaultModules () ;
  std::vector<int> defaultCrates();
}


///////////////////////////////////////////////////////////////////////////////

#include "framework/Registry.hpp"

FWK_REGISTRY_IMPL(tsim_l1ft,"$Name:  $")

///////////////////////////////////////////////////////////////////////////////


const string tsim_l1ft::version(){
    return "$Id: tsim_l1ft.cpp,v 1.7 1999/10/13 17:28:18 kinyip Exp $";
}

// Forward declaration for the cfttrk_ini routine
void cfttrk_ini(edm::RCP cft_rcp) ;



tsim_l1ft::tsim_l1ft(Context* context):
  Package(context), Process(context), JobSummary(context),
  _count(0)
{

  RCP _rcp = packageRCP();  //  get RCP for tsim_l1ft package

  ldebug = _rcp.getBool("Ldebug");
  //  Tell user initialization is done
  cout<<endl<<"tsim_l1ft: Initializing analysis package"<<endl;

  cft_para::get_CFT_geom(ldebug);

  RCP cfttrk_rcp = _rcp.getRCP( "cfttrk_rcp" );

  cfttrk_ini(cfttrk_rcp) ;

}



tsim_l1ft::~tsim_l1ft()
{
  //  cout << "Destructing tsim_l1ft Object" <<  endl;
}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Inputting Track Equations ..........
eqn_db TEF;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


Result tsim_l1ft::processEvent(edm::Event &event)
{
  _count++;

  // Get RCPID, EnvID ....
  std::list<edm::RCPID> rcps;
  std::list<edm::EnvID> envs;

  // An object of CFT tracks
  cft_trk evt_cfttrk(_count, event) ;
  FPS_L1ClusterChunk evt_FPSL1ClusterChunk( _count, event );

  SysID sysid = D0MCH::FT_L1 ;  // System ID
  std::vector<CTTHeader> headvec = evt_cfttrk.create_L1FTHeader() ;
  std::vector<CTTTrackChannel> trackvec = evt_cfttrk.create_L1trackchunk() ;
  std::vector<CTTCountChannel> countvec = evt_cfttrk.create_L1trackcount() ;
  std::vector<CTTClusterChannel>clustvec= evt_FPSL1ClusterChunk.create_fpsl1Chunk() ;

  if (ldebug) cout << "tsim_l1ft: Going to insert the FT_L1 chunk ... " 
		   << endl ;

  if ( headvec.size()>0  ) {

    // ChunkID : all FT_L1 always comes from FT_FE, right ?!

    UnpChunkSelector selec(D0MCH::FT_FE);

    const edm::TKey<UnpDataChunk> unpKey(selec);
    edm::THandle<UnpDataChunk> unpchunk=unpKey.find(event);
    std::list<edm::ChunkID> pars = unpchunk->parents() ;

    RunConfig config(D0MCH::defaultModules(),D0MCH::defaultCrates());

    UnpDataChunk* unl1ptr = new UnpDataChunk(sysid, config, rcps, envs, pars);

    std::vector<CTTHeader>::iterator i;
    for(i=headvec.begin();i!=headvec.end();i++){
      unl1ptr->addChannel(&(*i));
    };

    std::vector<CTTTrackChannel>::iterator j;
    for(j=trackvec.begin();j!=trackvec.end();j++){
      unl1ptr->addChannel(&(*j));
    };

    std::vector<CTTCountChannel>::iterator k;
    for(k=countvec.begin();k!=countvec.end();k++){
      unl1ptr->addChannel(&(*k));
    };

    std::vector<CTTClusterChannel>::iterator l;
    for(l=clustvec.begin();l!=clustvec.end();l++){
      unl1ptr->addChannel(&(*l));
    };

    std::auto_ptr<UnpDataChunk> autochunk(unl1ptr);

    // put it into the event
      
    edm::insertChunk(event, autochunk);

  }

  if ( ldebug ) {
    cout << "tsim_l1ft: Event " << _count << " : FT_L1 chunk inserted. " << endl ;

    evt_cfttrk.read_L1_FT(event, sysid) ;
  }

  if ( cft_trk::wrintp ) {
    //  storeCapturedData/clearData should be done only once for 1 ntuple
    //  even if you have more than 1 blocks !
    cft_trk::CFTL1_ntuple->storeCapturedData();   // fill ntuple
    cft_trk::CFTL1_ntuple->clearData();           // write to disk and clear
  }

  return Result::success;
}


Result tsim_l1ft::jobSummary(){

  out()<<endl<<" Processed "<<_count<<" events"<<endl;
  return Result::success;
}