class to handle first step of the shower reconstruction, mainly dedicated for ORCA More...

#include <JORCAShowerPrefit.hh>

Public Member Functions
	JORCAShowerPrefit ()
	Default constructor. More...

	JORCAShowerPrefit (const JLANG::JSharedPointer< const JDETECTOR::JModuleRouter > &moduleRouter, const JFIT::JShowerPrefitParameters_t &parameters)
	Parameterized constructor. More...

	~JORCAShowerPrefit ()

void	getJEvt (const KM3NETDAQ::JDAQTimeslice &timeSliceBuildL0, const KM3NETDAQ::JDAQTimeslice &timeSliceBuildL2, JFIT::JEvt &OutFits) const
	Declaration of Member function that actually performs the reconstruction. More...

Static Public Member Functions
static bool	totW (const JTRIGGER::JHitR1 &first, const JTRIGGER::JHitR1 &second)
	Member function used in the predicate of std::sort, to sort hits according to ToT and W. More...

Private Types
typedef JFIT::JRegressor < JPoint4D, JSimplex >	JRegressor_t

Private Attributes
std::shared_ptr< JRegressor_t >	fit2_

JLANG::JSharedPointer< const JDETECTOR::JModuleRouter >	moduleRouter_

JFIT::JShowerPrefitParameters_t	parameters_

Detailed Description

class to handle first step of the shower reconstruction, mainly dedicated for ORCA

Definition at line 55 of file JORCAShowerPrefit.hh.

Member Typedef Documentation

typedef JFIT::JRegressor<JPoint4D, JSimplex> JFIT::JORCAShowerPrefit::JRegressor_t

private

Definition at line 58 of file JORCAShowerPrefit.hh.

Constructor & Destructor Documentation

JFIT::JORCAShowerPrefit::JORCAShowerPrefit ( )

inline

Default constructor.

Definition at line 69 of file JORCAShowerPrefit.hh.

70 {}

JFIT::JORCAShowerPrefit::JORCAShowerPrefit	(	const JLANG::JSharedPointer< const JDETECTOR::JModuleRouter > &	moduleRouter,
		const JFIT::JShowerPrefitParameters_t &	parameters
	)

inline

Parameterized constructor.

Parameters

moduleRouter	JSharedPointer of JModuleRouter, this is built via detector file.
parameters	struct that holds default-optimized parameters for the reconstruction, which can be found in $JPP_DATA.

Definition at line 79 of file JORCAShowerPrefit.hh.

                                                                       :
       moduleRouter_(moduleRouter),
       parameters_(parameters)
     {
       JRegressor_t::debug  = 1;
       JRegressor_t::MAXIMUM_ITERATIONS = 10000; 
 
       fit2_ = std::make_shared<JRegressor_t>(true);
     }

JFIT::JORCAShowerPrefit::~JORCAShowerPrefit ( )

inline

Definition at line 90 of file JORCAShowerPrefit.hh.

90 {}

Member Function Documentation

void JFIT::JORCAShowerPrefit::getJEvt	(	const KM3NETDAQ::JDAQTimeslice &	timeSliceBuildL0,
		const KM3NETDAQ::JDAQTimeslice &	timeSliceBuildL2,
		JFIT::JEvt &	OutFits
	)		const

Declaration of Member function that actually performs the reconstruction.

member function definition

Parameters

timeSliceBuildL0	which is contructed via a JDAQEvent
timeSliceBuildL2	which is contructed via a JDAQEvent
OutFits	non const (output) JEvt.

Definition at line 129 of file JORCAShowerPrefit.hh.

 {
   const double                   Tmax_ns   = parameters_.Tmax_ns;  // [ns] 
   const double                   ctMin     = parameters_.ctMin;  // optimal value
   const double                   Dmax_m    = parameters_.Dmax_m;  // [m] optimal value 
   const JTOOLS::JRange<double>   pos_grid  = parameters_.pos_grid;
   const JTOOLS::JRange<double>   time_grid = parameters_.time_grid;
   const double                   pos_step  = parameters_.pos_step;  // [m] density of the grid
   const double                   time_step = parameters_.time_step;  // [ns] density of the grid
   const double                   sigma_ns  = parameters_.sigma_ns;
   const int                      numberOfOutliers = parameters_.numberOfOutliers;
   const bool                     useL0     = parameters_.useL0;
   
   const int    FACTORY_LIMIT             = 40;
   const double STANDARD_DEVIATIONS       = 1.0;
   const int    NUMBER_OF_L1HITS          = (useL0 ? 1 : 4);
 
   typedef std::vector<JTRIGGER::JHitL0> JDataL0_t;
   typedef std::vector<JTRIGGER::JHitL1> JDataL1_t;
 
   const JTRIGGER::JBuildL0<JTRIGGER::JHitL0> buildL0;
   const JTRIGGER::JBuildL2<JTRIGGER::JHitL1> buildL2(2, Tmax_ns, ctMin);
   const JTRIGGER::JMatch3G<JTRIGGER::JHitL1> match3G(Dmax_m, Tmax_ns); // CAUSALITY FOR SHOWERS
   const JFIT::JHitL1Comparator compare;
   
   //define empty vectors to fill with JHitL0 and JHitL1
   JDataL0_t dataL0;
   JDataL0_t dataL0_selected;
   JDataL1_t data;
   
   buildL0(timeSliceBuildL0,  *moduleRouter_, back_inserter(dataL0));
   buildL2(timeSliceBuildL1, *moduleRouter_, back_inserter(data));
   
   JDataL1_t::iterator __end = clusterizeWeight(data.begin(), data.end(), match3G);
   
   if(std::distance(data.begin(), __end) >= NUMBER_OF_L1HITS){
     
     JDataL1_t dataL1;
     std::copy(data.begin(), data.end(), std::back_inserter(dataL1));
     JDataL1_t::iterator __end1 = dataL1.end();
     
     __end1 = clusterizeWeight(dataL1.begin(), __end1, match3G);
     
     if (useL0) {
       
       dataL1.erase(__end1, dataL1.end()); 
       dataL1.reserve(dataL1.size() + dataL0.size());
       __end1 = dataL1.end();
       
       for (JDataL0_t::const_iterator i = dataL0.begin(); i != dataL0.end(); ++i) {
         
         const JTRIGGER::JHitL1 hit(*i);
         
         if (std::count_if(dataL1.begin(), __end1, JTRIGGER::JBind2nd(match3G,hit)) >= NUMBER_OF_L1HITS){
           dataL1.push_back(hit);            
         }
       }
       
       std::sort(__end1, dataL1.end(), compare);
       __end1 = clusterize(__end1, dataL1.end(), match3G);
 
     }
     
     // 4D fit
     JFIT::JEstimator<JFIT::JPoint4D> fit;
     JFIT::JPoint4D vx;
     double   chi2 = std::numeric_limits<double>::max();
     int      NDF  = 0;
     int      N    = 0;
     
     if(std::distance(dataL1.begin(), __end1) <= FACTORY_LIMIT){
       
       double ymin = std::numeric_limits<double>::max();
       
       JDataL1_t::iterator __end2 = __end1;
       
       for (int n = 0; n <= numberOfOutliers && std::distance(dataL1.begin(), __end2) > 
              JFIT::JEstimator<JFIT::JPoint4D>::NUMBER_OF_PARAMETERS; ++n, --__end2) {
                 
         std::sort(dataL1.begin(), __end1, compare);
         
         do {
           try {
             
             fit(dataL1.begin(), __end2);
             double y = JFIT::getChi2(fit, dataL1.begin(), __end2, sigma_ns);
             
             if (y <= 0.0) {
               std::cout << "chi2(1) " << y << std::endl; // <- it was used WARNING, which gives a bug.
             } else if (y < ymin) {
               ymin = y;
               vx   = fit;
               NDF  = std::distance(dataL1.begin(), __end2) - JFIT::JEstimator<JFIT::JPoint4D>::NUMBER_OF_PARAMETERS;
               N    = JFIT::getCount(dataL1.begin(), __end2);
               chi2 = y;
             }
           }
           catch(JLANG::JException& error) {}
           
         } while (JTOOLS::next_permutation(dataL1.begin(), __end2, __end1, compare));
         
         ymin -= STANDARD_DEVIATIONS * STANDARD_DEVIATIONS;
       }
       
     } else {
       
       try{      
         fit(dataL1.begin(), __end1);
         NDF  = std::distance(dataL1.begin(), __end1) - JEstimator<JFIT::JPoint4D>::NUMBER_OF_PARAMETERS;
         N    = JFIT::getCount(dataL1.begin(), __end1);
         vx   = fit;
         chi2 = JFIT::getChi2(fit, dataL1.begin(), __end1, sigma_ns);
       }
       catch(const JLANG::JException& error){}
     }
     
     if (NDF >= 0) {
             
       for(double x = pos_grid.getLowerLimit(); x <= pos_grid.getUpperLimit(); x += pos_step){
         for(double y = pos_grid.getLowerLimit(); y <= pos_grid.getUpperLimit(); y += pos_step){
           for(double z = pos_grid.getLowerLimit(); z <= pos_grid.getUpperLimit(); z += pos_step){
             for(double t = time_grid.getLowerLimit(); t <= time_grid.getUpperLimit(); t += time_step){
 
               const JGEOMETRY3D::JVector3D pos_shifted(vx.getX() + x, vx.getY() + y, vx.getZ() + z);
               const JFIT::JPoint4D point_shifted(pos_shifted, vx.getT() + t);
               
               dataL0_selected.clear();
               
               //select a subcluster of L0s
               const JFIT::JModel<JFIT::JPoint4D> match(vx, 80, JTOOLS::JTimeRange(-100, +100));
               
               for (JDataL0_t::const_iterator i = dataL0.begin(); i != dataL0.end(); ++i) {       
                 
                 const JHitL0 hit(*i);
                 
                 if(match(hit)){
                   dataL0_selected.push_back(hit);
                 }
               }
               
               double simplex_step = 2;  // [m]
               fit2_->step.resize(4);
               fit2_->step[0] = JFIT::JPoint4D(JVector3D(simplex_step, 0.0, 0.0), 0.0);
               fit2_->step[1] = JFIT::JPoint4D(JVector3D(0.0, simplex_step, 0.0), 0.0);
               fit2_->step[2] = JFIT::JPoint4D(JVector3D(0.0, 0.0, simplex_step), 0.0);
               fit2_->step[3] = JFIT::JPoint4D(JVector3D(0.0, 0.0, 0.0), 20);
        
               chi2 = (*fit2_)(point_shifted, dataL0_selected.begin(), dataL0_selected.end());
        
               const JGEOMETRY3D::JVector3D fitPos(fit2_->value);
               const JGEOMETRY3D::JTrack3D fitResult(fitPos, JGEOMETRY3D::JVersor3Z(), fit2_->value.getT());
 
               const double energy(0);
               const JFIT::JFit &outFit = JFIT::getFit(JFIT::JHistory(JSHOWERPREFIT), 
                                                       fitResult, getQuality(chi2, (useL0 ? N : NDF)),
                                                       NDF, energy,JFIT::JFitStatus_t::OKAY );
                                               
               OutFits.push_back(outFit);
               OutFits.rbegin()->setW(13, chi2);
               OutFits.rbegin()->setW(14, NDF);
               
             }
           }
         }
       }
     }
     std::sort(OutFits.begin(), OutFits.end(), qualitySorter);
   }else{
     std::cout<<"Too few hits " << std::endl;// <- it was used DEBUG, which gives a bug.
   }
   
 }

static bool JFIT::JORCAShowerPrefit::totW	(	const JTRIGGER::JHitR1 &	first,
		const JTRIGGER::JHitR1 &	second
	)

inlinestatic

Member function used in the predicate of std::sort, to sort hits according to ToT and W.

Parameters

first	lhs hit
second	rhs hit

Definition at line 113 of file JORCAShowerPrefit.hh.

     {
       return (first.getToT() + first.getW() > second.getToT() + second.getW());
     }

Member Data Documentation

std::shared_ptr<JRegressor_t> JFIT::JORCAShowerPrefit::fit2_

private

Definition at line 59 of file JORCAShowerPrefit.hh.

JLANG::JSharedPointer<const JDETECTOR::JModuleRouter> JFIT::JORCAShowerPrefit::moduleRouter_

private

Definition at line 61 of file JORCAShowerPrefit.hh.

JFIT::JShowerPrefitParameters_t JFIT::JORCAShowerPrefit::parameters_

private

Definition at line 62 of file JORCAShowerPrefit.hh.

The documentation for this class was generated from the following file:

JORCAShowerPrefit.hh

Public Member Functions

Static Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation