#include <imath.h>

Inheritance diagram for trklet::VarFlag:

Public Member Functions
void	add_cut (VarBase *cut, const bool call_set_parent_flag=true)

template<class... Args>
void	add_cuts (VarBase *cut, Args...args)

void	add_cuts (VarBase *cut)

void	calculate_step ()

bool	passes ()

void	print (std::ofstream &fs, Verilog, int l1=0, int l2=0, int l3=0) override

void	print (std::ofstream &fs, HLS, int l1=0, int l2=0, int l3=0) override

template<class... Args>
	VarFlag (imathGlobals globals, std::string name, VarBase cut, Args...args)

Public Member Functions inherited from trklet::VarBase
void	add_cut (VarCut *cut, const bool call_set_cut_var=true)

void	add_delay (int i)

void	add_latency (unsigned int l)

void	analyze ()

bool	calculate (int debug_level)

bool	calculate ()

VarBase *	cut_var ()

std::string	dump ()

void	dump_msg ()

double	fval () const

bool	has_delay (int i)

void	inputs (std::vector< VarBase * > *vd)

long int	ival () const

double	K () const

std::map< std::string, int >	Kmap () const

std::string	kstring () const

int	latency () const

virtual void	local_calculate ()

bool	local_passes () const

void	makeready ()

double	maxval () const

double	minval () const

std::string	name () const

int	nbits () const

std::string	op () const

VarBase *	p1 () const

VarBase *	p2 () const

VarBase *	p3 () const

void	passes (std::map< const VarBase , std::vector< bool > > &passes, const std::map< const VarBase , std::vector< bool > > *const previous_passes=nullptr) const

int	pipe_counter ()

std::string	pipe_delays (const int step)

void	pipe_increment ()

void	print_all (std::ofstream &fs, Verilog)

void	print_all (std::ofstream &fs, HLS)

void	print_cuts (std::map< const VarBase , std::set< std::string > > &cut_strings, const int step, Verilog, const std::map< const VarBase , std::set< std::string > > *const previous_cut_strings=nullptr) const

void	print_cuts (std::map< const VarBase , std::set< std::string > > &cut_strings, const int step, HLS, const std::map< const VarBase , std::set< std::string > > *const previous_cut_strings=nullptr) const

void	print_step (int step, std::ofstream &fs, Verilog)

void	print_step (int step, std::ofstream &fs, HLS)

void	print_truncation (std::string &t, const std::string &o1, const int ps, Verilog) const

void	print_truncation (std::string &t, const std::string &o1, const int ps, HLS) const

double	range () const

void	reset ()

int	shift () const

int	step () const

	VarBase (imathGlobals globals, std::string name, VarBase p1, VarBase p2, VarBase p3, int l)

virtual	~VarBase ()

Additional Inherited Members
Static Public Member Functions inherited from trklet::VarBase
static void	design_print (const std::vector< VarBase * > &v, std::ofstream &fs, Verilog)

static void	design_print (const std::vector< VarBase * > &v, std::ofstream &fs, HLS)

static void	hls_print (const std::vector< VarBase * > &v, std::ofstream &fs)

static std::string	itos (int i)

static std::string	pipe_delay (VarBase *v, int nbits, int delay)

static std::string	pipe_delay_wire (VarBase *v, std::string name_delayed, int nbits, int delay)

static void	verilog_print (const std::vector< VarBase * > &v, std::ofstream &fs)

Static Public Attributes inherited from trklet::VarBase
static struct trklet::VarBase::HLS	hls

static struct trklet::VarBase::Verilog	verilog

Protected Attributes inherited from trklet::VarBase
VarBase *	cut_var_

std::vector< VarBase * >	cuts_

double	fval_

imathGlobals *	globals_

long int	ival_

double	K_

std::map< std::string, int >	Kmap_

int	latency_

double	maxval_

double	minval_

std::string	name_

int	nbits_

std::string	op_

VarBase *	p1_

VarBase *	p2_

VarBase *	p3_

int	pipe_counter_

std::vector< int >	pipe_delays_

bool	readytoanalyze_

bool	readytoprint_

int	step_

bool	usedasinput_

double	val_

Detailed Description

Definition at line 1095 of file imath.h.

Constructor & Destructor Documentation

template<class... Args>

trklet::VarFlag::VarFlag	(	imathGlobals *	globals,
		std::string	name,
		VarBase *	cut,
		Args...	args
	)

inline

Definition at line 1098 of file imath.h.

References add_cuts(), writedatasetfile::args, trklet::VarBase::nbits_, and trklet::VarBase::op_.

         : VarBase(globals, name, nullptr, nullptr, nullptr, 0) {
       op_ = "flag";
       nbits_ = 1;
       add_cuts(cut, args...);
     }

Member Function Documentation

void VarFlag::add_cut	(	VarBase *	cut,
		const bool	call_set_parent_flag = `true`
	)

Definition at line 373 of file imath.cc.

References calculate_step(), trklet::VarBase::cuts_, trklet::VarBase::op(), and trklet::VarCut::set_parent_flag().

Referenced by add_cuts(), trklet::IMATH_TrackletCalculator::IMATH_TrackletCalculator(), trklet::IMATH_TrackletCalculatorDisk::IMATH_TrackletCalculatorDisk(), trklet::IMATH_TrackletCalculatorOverlap::IMATH_TrackletCalculatorOverlap(), and trklet::VarCut::set_parent_flag().

                                                                    {
   cuts_.push_back(cut);
   if (cut->op() == "cut" && call_set_parent_flag) {
     VarCut *const cast_cut = (VarCut *)cut;
     cast_cut->set_parent_flag(this, false);
   }
   calculate_step();
 }

template<class... Args>

void trklet::VarFlag::add_cuts	(	VarBase *	cut,
		Args...	args
	)

inline

Definition at line 1106 of file imath.h.

References add_cut(), and writedatasetfile::args.

Referenced by VarFlag().

                                               {
       add_cut(cut);
       add_cuts(args...);
     }

void trklet::VarFlag::add_cuts ( VarBase * cut )

inline

Definition at line 1111 of file imath.h.

References add_cut().

1111 { add_cut(cut); }

trklet::VarFlag::add_cut

void add_cut(VarBase *cut, const bool call_set_parent_flag=true)

Definition: imath.cc:373

GOODCOLL_filter_cfg.cut

tuple cut

Definition: GOODCOLL_filter_cfg.py:65

void VarFlag::calculate_step ( )

Definition at line 81 of file imath_calculate.cc.

References GOODCOLL_filter_cfg::cut, trklet::VarBase::cuts_, and trklet::VarBase::step_.

Referenced by add_cut(), and trklet::VarCut::set_cut_var().

                              {
   int max_step = 0;
   for (const auto &cut : cuts_) {
     if (!cut->cut_var())
       continue;
     if (cut->cut_var()->latency() + cut->cut_var()->step() > max_step)
       max_step = cut->cut_var()->latency() + cut->cut_var()->step();
   }
   step_ = max_step;
 }

bool VarFlag::passes ( )

Definition at line 395 of file imath.cc.

References GOODCOLL_filter_cfg::cut, trklet::VarBase::cut_var(), trklet::VarBase::cuts_, trklet::VarBase::globals_, trklet::VarBase::local_passes(), trklet::VarCut::local_passes(), trklet::VarBase::name_, and trklet::imathGlobals::printCutInfo_.

                      {
   if (globals_->printCutInfo_) {
     edm::LogVerbatim("Tracklet") << "Checking if " << name_ << " passes...";
   }
 
   std::map<const VarBase *, std::vector<bool> > passes0, passes1;
   for (const auto &cut : cuts_) {
     if (cut->op() != "cut")
       continue;
     const VarCut *const cast_cut = (VarCut *)cut;
     cast_cut->local_passes(passes0);
   }
   for (const auto &cut : cuts_) {
     if (cut->op() != "cut")
       cut->passes(passes1, &passes0);
     else {
       if (cut->cut_var()->p1())
         cut->cut_var()->p1()->passes(passes1, &passes0);
       if (cut->cut_var()->p2())
         cut->cut_var()->p2()->passes(passes1, &passes0);
       if (cut->cut_var()->p3())
         cut->cut_var()->p3()->passes(passes1, &passes0);
     }
   }
 
   bool passes = true;
   for (const auto &cut_var : passes0) {
     bool local_passes = false;
     for (const auto pass : cut_var.second)
       local_passes = local_passes || pass;
     passes = passes && local_passes;
   }
   for (const auto &cut_var : passes1) {
     bool local_passes = false;
     for (const auto pass : cut_var.second)
       local_passes = local_passes || pass;
     passes = passes && local_passes;
   }
 
   if (globals_->printCutInfo_) {
     edm::LogVerbatim("Tracklet") << name_ << " " << (passes ? "PASSES" : "FAILS");
   }
 
   return passes;
 }

void VarFlag::print	(	std::ofstream &	fs,
		Verilog	,
		int	l1 = `0`,
		int	l2 = `0`,
		int	l3 = `0`
	)

overridevirtual

Reimplemented from trklet::VarBase.

Definition at line 354 of file imath_Verilog.cc.

References cms::cuda::assert(), GOODCOLL_filter_cfg::cut, trklet::VarBase::cut_var(), trklet::VarBase::cuts_, trklet::VarBase::name_, trklet::VarCut::print(), edm::separator(), trklet::VarBase::step_, AlCaHLTBitMon_QueryRunRegistry::string, and trklet::VarBase::verilog.

                                                                     {
   assert(l1 == 0);
   assert(l2 == 0);
   assert(l3 == 0);
 
   fs << "wire " << name_ << ";" << std::endl;
   fs << "assign " << name_ << " = (";
   std::map<const VarBase*, std::set<std::string> > cut_strings0, cut_strings1;
   for (const auto& cut : cuts_) {
     if (cut->op() != "cut")
       continue;
     const VarCut* const cast_cut = (VarCut*)cut;
     cast_cut->print(cut_strings0, step_, verilog);
   }
   for (const auto& cut : cuts_) {
     if (cut->op() != "cut")
       cut->print_cuts(cut_strings1, step_, verilog, &cut_strings0);
     else {
       if (cut->cut_var()->p1())
         cut->cut_var()->p1()->print_cuts(cut_strings1, step_, verilog, &cut_strings1);
       if (cut->cut_var()->p2())
         cut->cut_var()->p2()->print_cuts(cut_strings1, step_, verilog, &cut_strings1);
       if (cut->cut_var()->p3())
         cut->cut_var()->p3()->print_cuts(cut_strings1, step_, verilog, &cut_strings1);
     }
   }
 
   std::string separator = "";
   for (const auto& cut_var : cut_strings0) {
     separator += "((";
     for (const auto& cut_string : cut_var.second) {
       fs << separator << cut_string;
       separator = ") || (";
     }
     separator = ")) && ";
   }
   for (const auto& cut_var : cut_strings1) {
     separator += "((";
     for (const auto& cut_string : cut_var.second) {
       fs << separator << cut_string;
       separator = ") || (";
     }
     separator = ")) && ";
   }
 
   fs << ")));";
 }

void VarFlag::print	(	std::ofstream &	fs,
		HLS	,
		int	l1 = `0`,
		int	l2 = `0`,
		int	l3 = `0`
	)

overridevirtual

Reimplemented from trklet::VarBase.

Definition at line 284 of file imath_HLS.cc.

References cms::cuda::assert(), GOODCOLL_filter_cfg::cut, trklet::VarBase::cut_var(), trklet::VarBase::cuts_, trklet::VarBase::hls, trklet::VarBase::name_, trklet::VarCut::print(), edm::separator(), trklet::VarBase::step_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                 {
   assert(l1 == 0);
   assert(l2 == 0);
   assert(l3 == 0);
 
   fs << "const ap_int<1> " << name_ << " = (";
   std::map<const VarBase*, std::set<std::string> > cut_strings0, cut_strings1;
   for (const auto& cut : cuts_) {
     if (cut->op() != "cut")
       continue;
     const VarCut* const cast_cut = (VarCut*)cut;
     cast_cut->print(cut_strings0, step_, hls);
   }
   for (const auto& cut : cuts_) {
     if (cut->op() != "cut")
       cut->print_cuts(cut_strings1, step_, hls, &cut_strings0);
     else {
       if (cut->cut_var()->p1())
         cut->cut_var()->p1()->print_cuts(cut_strings1, step_, hls, &cut_strings1);
       if (cut->cut_var()->p2())
         cut->cut_var()->p2()->print_cuts(cut_strings1, step_, hls, &cut_strings1);
       if (cut->cut_var()->p3())
         cut->cut_var()->p3()->print_cuts(cut_strings1, step_, hls, &cut_strings1);
     }
   }
 
   std::string separator = "";
   for (const auto& cut_var : cut_strings0) {
     separator += "((";
     for (const auto& cut_string : cut_var.second) {
       fs << separator << cut_string;
       separator = ") || (";
     }
     separator = ")) && ";
   }
   for (const auto& cut_var : cut_strings1) {
     separator += "((";
     for (const auto& cut_string : cut_var.second) {
       fs << separator << cut_string;
       separator = ") || (";
     }
     separator = ")) && ";
   }
 
   fs << ")));";
 }

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation