#if !defined(__CLING__) || defined(__ROOTCLING__)

#include <memory>

#include <string>

#include <TChain.h>

#include <TFile.h>

#include <TTree.h>

#include <TGeoGlobalMagField.h>

#include <FairEventHeader.h>

#include <FairGeoParSet.h>

#include <FairLogger.h>

#include <FairMCEventHeader.h>

#include "DetectorsCommonDataFormats/DetID.h"

#include "DataFormatsITSMFT/Cluster.h"

#include "DataFormatsParameters/GRPObject.h"

#include "DetectorsBase/GeometryManager.h"

#include "DetectorsBase/Propagator.h"

#include "Field/MagneticField.h"

#include "ITSBase/GeometryTGeo.h"

#include "ITStracking/Event.h"

#include "ITStracking/IOUtils.h"

#include "ITStracking/Tracker.h"

#include "ITStracking/Vertexer.h"

#include "MathUtils/Utils.h"

#include "SimulationDataFormat/MCCompLabel.h"

#include "SimulationDataFormat/MCTruthContainer.h"

void run_rec_ca_its(std::string path = "./",

std::tuple<float, float, float, float, int> initParams = { 0.005, 0.002, 0.04, 0.8, 5 },

std::string outputfile = "o2ca_its.root",

std::string inputClustersITS = "o2clus_its.root", std::string inputGeom = "O2geometry.root",

std::string inputGRP = "o2sim_grp.root", std::string simfilename = "o2sim.root",

std::string paramfilename = "o2sim_par.root")

{

o2::ITS::CA::Tracker<false> tracker;

o2::ITS::CA::Event event;

if (path.back() != '/') {

path += '/';

}

//-------- init geometry and field --------//

const auto grp = o2::parameters::GRPObject::loadFrom(path + inputGRP);

if (!grp) {

LOG(FATAL) << "Cannot run w/o GRP object" << FairLogger::endl;

}

o2::Base::GeometryManager::loadGeometry(path + inputGeom, "FAIRGeom");

o2::Base::Propagator::initFieldFromGRP(grp);

auto field = static_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());

if (!field) {

LOG(FATAL) << "Failed to load ma" << FairLogger::endl;

}

double origD[3] = { 0., 0., 0. };

tracker.setBz(field->getBz(origD));

bool isITS = grp->isDetReadOut(o2::detectors::DetID::ITS);

if (!isITS) {

LOG(WARNING) << "ITS is not in the readoute" << FairLogger::endl;

return;

}

bool isContITS = grp->isDetContinuousReadOut(o2::detectors::DetID::ITS);

LOG(INFO) << "ITS is in " << (isContITS ? "CONTINUOS" : "TRIGGERED") << " readout mode" << FairLogger::endl;

auto gman = o2::ITS::GeometryTGeo::Instance();

gman->fillMatrixCache(o2::utils::bit2Mask(o2::TransformType::T2L, o2::TransformType::T2GRot,

o2::TransformType::L2G)); // request cached transforms

// Get event header

TChain mcHeaderTree("o2sim");

mcHeaderTree.AddFile(simfilename.data());

FairMCEventHeader* mcHeader = nullptr;

if (!mcHeaderTree.GetBranch("MCEventHeader.")) {

LOG(FATAL) << "Did not find MC event header in the input header file." << FairLogger::endl;

}

mcHeaderTree.SetBranchAddress("MCEventHeader.", &mcHeader);

//>>>---------- attach input data --------------->>>

TChain itsClusters("o2sim");

itsClusters.AddFile((path + inputClustersITS).data());

//<<<---------- attach input data ---------------<<<

if (!itsClusters.GetBranch("ITSCluster")) {

LOG(FATAL) << "Did not find ITS clusters branch ITSCluster in the input tree" << FairLogger::endl;

}

std::vector<o2::ITSMFT::Cluster>* clusters = nullptr;

itsClusters.SetBranchAddress("ITSCluster", &clusters);

if (!itsClusters.GetBranch("EventHeader.")) {

LOG(FATAL) << "Did not find the EventHeader branch in the input cluster tree" << FairLogger::endl;

}

FairEventHeader* header = nullptr;

itsClusters.SetBranchAddress("EventHeader.", &header);

if (!itsClusters.GetBranch("ITSClusterMCTruth")) {

LOG(FATAL) << "Did not find ITS clusters branch ITSClusterMCTruth in the input tree" << FairLogger::endl;

}

o2::dataformats::MCTruthContainer<o2::MCCompLabel>* labels = nullptr;

itsClusters.SetBranchAddress("ITSClusterMCTruth", &labels);

// create/attach output tree

TFile outFile((path + outputfile).data(), "recreate");

TTree outTree("o2sim", "CA ITS Tracks");

std::vector<o2::ITS::TrackITS>* tracksITS = new std::vector<o2::ITS::TrackITS>;

o2::dataformats::MCTruthContainer<o2::MCCompLabel>* trackLabels =

new o2::dataformats::MCTruthContainer<o2::MCCompLabel>;

outTree.Branch("EventHeader.", &header);

outTree.Branch("ITSTrack", &tracksITS);

outTree.Branch("ITSTrackMCTruth", &trackLabels);

//-------------------- settings -----------//

std::uint32_t roFrame = 0;

for (int iEvent = 0; iEvent < itsClusters.GetEntries(); ++iEvent) {

itsClusters.GetEntry(iEvent);

mcHeaderTree.GetEntry(iEvent);

if (isContITS) {

int nclLeft = clusters->size();

while (nclLeft > 0) {

int nclUsed = o2::ITS::CA::IOUtils::loadROFrameData(roFrame, event, clusters, labels);

if (nclUsed) {

cout << "Event " << iEvent << " ROFrame " << roFrame << std::endl;

o2::ITS::CA::Vertexer vertexer(event);

vertexer.setROFrame(roFrame);

vertexer.initialise(initParams);

vertexer.findTracklets();

vertexer.findVertices();

tracker.setROFrame(roFrame);

tracker.clustersToTracks(event);

tracksITS->swap(tracker.getTracks());

*trackLabels = tracker.getTrackLabels(); /// FIXME: assignment ctor is not optimal.

outTree.Fill();

nclLeft -= nclUsed;

}

roFrame++;

}

} else { // triggered mode

cout << "Event " << iEvent << std::endl;

o2::ITS::CA::IOUtils::loadEventData(event, clusters, labels);

o2::ITS::CA::Vertexer vertexer(event);

vertexer.initialise(initParams);

vertexer.findTracklets();

vertexer.findVertices();

tracker.clustersToTracks(event);

tracksITS->swap(tracker.getTracks());

*trackLabels = tracker.getTrackLabels(); /// FIXME: assignment ctor is not optimal.

outTree.Fill();

}

}

outFile.cd();

outTree.Write();

outFile.Close();

}

#endif