CombinatoricJigsaw.hh

Go to the documentation of this file.

//   RestFrames: particle physics event analysis library
//   --------------------------------------------------------------------
//   Copyright (c) 2014-2016, Christopher Rogan
//   This file is part of RestFrames.
//
//   RestFrames is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
// 
//   RestFrames is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.
// 
//   You should have received a copy of the GNU General Public License
//   along with RestFrames. If not, see <http://www.gnu.org/licenses/>.
 
#ifndef CombinatoricJigsaw_HH
#define CombinatoricJigsaw_HH
 
#include "RestFrames/RestFrame.hh"
#include "RestFrames/Jigsaw.hh"
#include "RestFrames/CombinatoricGroup.hh"
#include "RestFrames/CombinatoricState.hh"
 
namespace RestFrames {
 
  class CombinatoricJigsaw : public Jigsaw {
  public:
 
    CombinatoricJigsaw(const std::string& sname, 
               const std::string& stitle,
               int Ncomb, int Nobject);
 
    CombinatoricJigsaw();
    virtual ~CombinatoricJigsaw();
 
    virtual void Clear();
 
    static CombinatoricJigsaw& Empty();
 
    virtual void SetGroup(Group& group = Group::Empty());
 
    virtual CombinatoricGroup& GetGroup() const;
 
    virtual void AddCombFrame(const RestFrame& frame, int i = 0);
 
    void AddCombFrames(const ConstRestFrameList& frames, int i = 0);
 
    virtual void AddObjectFrame(const RestFrame& frame, int i = 0);
 
    void AddObjectFrames(const ConstRestFrameList& frames, int i = 0);
 
    void SetCombCharge(const RFCharge& charge, int i);
 
    void SetCombCharge(int charge, int i);
 
    void SetCombCharge(int charge_num, int charge_den, int i);
 
    void UnsetCombCharge(int i);
 
    void SetObjectCharge(const RFCharge& charge, int i);
 
    void SetObjectCharge(int charge, int i);
 
    void SetObjectCharge(int charge_num, int charge_den, int i);
    
    void UnsetObjectCharge(int i);
 
    void SetTransverse(bool tran = true, const TVector3& axis = RestFrame::GetAxis());
 
  protected:
    virtual bool IsSoundBody() const;
    CombinatoricState& GetNewChildState();
    
    virtual bool InitializeAnalysis();
 
    virtual bool InitializeCombinatoric();
    virtual bool LoopCombinatoric();
 
    virtual bool EvaluateMetric(double& metric) const = 0;
 
    virtual bool AnalyzeEvent();
    
    int GetNInputStates() const; 
    VisibleState& GetInputState(int i = 0) const;
 
    int GetNinputForChild(int i = 0) const;
    bool IsNinputExclForChild(int i = 0) const;
 
    bool IsChargeSetForChild(int i = 0) const;
    RFCharge GetChargeForChild(int i = 0) const;
    bool IsChargeSetForObject(int i = 0) const;
    RFCharge GetChargeForObject(int i = 0) const;
 
    void SetParentState(State& state = State::Empty());
    CombinatoricState const& GetParentState() const;
    
    CombinatoricState& GetChildState(int i) const;
 
    bool InitializeJigsawExecutionList(JigsawList& exec_jigsaws, JigsawList& todo_jigsaws);
 
    JigsawList m_ExecuteJigsaws;
    bool ExecuteDependancyJigsaws();
 
    bool IsTransverse() const;
    const TVector3& GetTransverseAxis() const;
 
  private:
    const int m_Ncomb;
    const int m_Nobj;
 
    VisibleStateList m_InputStates;
 
    int m_NinputTOT;
    bool m_NExclusiveTOT;
    std::vector<int> m_NForChild;
    std::vector<int> m_NExclusive;
    mutable std::map<int, RFCharge> m_ChargeForChild;
    mutable std::map<int, RFCharge> m_ChargeForObject;
 
    bool m_SetTransverse;
    TVector3 m_TranAxis;
  };
 
}
 
#endif