Derived class of TrackFilterFactory with a truth target that also discards clones Probably this whole class could be removed if TrackFilterFactory would be templated with the type of the TruthVarSet as a template argument. More...

#include <TrackQualityFilterFactory.h>

Inheritance diagram for TrackQualityFilterFactory:

Public Types
using	CreatedFilter = BaseTrackFilter
	Type of the filter that this factory creates.

Public Member Functions
std::string	getFilterPurpose () const override
	Getter for a descriptive purpose of the constructed filters.

std::unique_ptr< BaseTrackFilter >	create (const std::string &filterName) const override
	Create a filter with the given name.

std::string	getIdentifier () const override
	Getter for a short identifier for the factory.

std::map< std::string, std::string >	getValidFilterNamesAndDescriptions () const override
	Getter for valid filter names and a description for each.

virtual std::string	createFiltersNameDescription () const
	Create a string with a description mentioning the names of the chooseable filter.

virtual std::string	createFiltersParametersDescription () const
	Create a string with a description mentioning the parameters of the chooseable filter.

const std::string &	getDefaultFilterName () const
	Legacy - Return the default filter suggested by the factory.

Private Types
using	Super = TrackFilterFactory
	Type of the base class.

Private Attributes
std::string	m_defaultFilterName
	Legacy - Default filter name suggested by this factory.

Detailed Description

Derived class of TrackFilterFactory with a truth target that also discards clones Probably this whole class could be removed if TrackFilterFactory would be templated with the type of the TruthVarSet as a template argument.

Definition at line 27 of file TrackQualityFilterFactory.h.

Member Typedef Documentation

◆ CreatedFilter

using CreatedFilter = BaseTrackFilter

inherited

Type of the filter that this factory creates.

Definition at line 29 of file FilterFactory.dcl.h.

◆ Super

using Super = TrackFilterFactory

private

Type of the base class.

Definition at line 30 of file TrackQualityFilterFactory.h.

Member Function Documentation

◆ create()

std::unique_ptr< BaseTrackFilter > create ( const std::string & filterName ) const

overridevirtual

Create a filter with the given name.

Reimplemented from TrackFilterFactory.

Definition at line 49 of file TrackQualityFilterFactory.cc.

{
  if (filterName == "none") {
    return std::make_unique<NoneTrackFilter>();
  } else if (filterName == "all") {
    return std::make_unique<AllTrackFilter>();
  } else if (filterName == "truth") {
    return std::make_unique<MCTrackFilter>();
  } else if (filterName == "recording") {
    return std::make_unique<RecordingTrackFilter>("TrackQualityFilter.root");
  } else if (filterName == "recording_data") {
    return std::make_unique<RecordingDataTrackFilter>("TrackQualityFilter.root");
  } else if (filterName == "eval") {
    auto recordedVarSets = std::make_unique<UnionVarSet<CDCTrack>>();
    using TrackFilterVarSet = FilterVarSet<BaseTrackFilter>;
    recordedVarSets->push_back(std::make_unique<TrackFilterVarSet>("mva", create("mva")));
    recordedVarSets->push_back(std::make_unique<TrackFilterVarSet>("truth", create("truth")));
    return std::make_unique<Recording<BaseTrackFilter>>(std::move(recordedVarSets),
                                                        "TrackQualityFilter_eval.root");
  } else if (filterName == "mva") {
    return std::make_unique<MVATrackFilter>("trackfindingcdc_TrackQualityIndicator", 0.10);
  } else {
    return Super::create(filterName);
  }
}

◆ createFiltersNameDescription()

std::string createFiltersNameDescription

virtualinherited

Create a string with a description mentioning the names of the chooseable filter.

Definition at line 56 of file FilterFactory.icc.h.

    {
      // Compose description for the filter names
      std::ostringstream oss;
      oss << this->getFilterPurpose();
      oss << "Allowed values are: ";
      std::vector<std::string> filterNameAndDescriptions;
      for (const auto& filterNameAndDescription : this->getValidFilterNamesAndDescriptions()) {
        const std::string& filterName = filterNameAndDescription.first;
        const std::string& filterDescription = filterNameAndDescription.second;
        filterNameAndDescriptions.push_back(quoted(filterName) + " " + bracketed(filterDescription));
      }
      oss << join(", ", filterNameAndDescriptions);
      return oss.str();
    }

◆ createFiltersParametersDescription()

std::string createFiltersParametersDescription

virtualinherited

Create a string with a description mentioning the parameters of the chooseable filter.

Definition at line 59 of file FilterFactory.icc.h.

    {
      // Compose description for the filter parameters
      std::ostringstream oss;
      oss << "Key -- value pairs depending on the filter." << std::endl;
      for (const auto& filterNameAndDescription : this->getValidFilterNamesAndDescriptions()) {
 
        const std::string& filterName = filterNameAndDescription.first;
        // const std::string& filterDescription = filterNameAndDescription.second;
 
        std::unique_ptr<AFilter> filter = this->create(filterName);
        if (not filter) {
          B2WARNING("Could not create a filter for name " << filterName);
          continue;
        }
 
        ModuleParamList moduleParamList;
        const std::string prefix = "";
        filter->exposeParameters(&moduleParamList, prefix);
 
        std::map<std::string, std::string> filterParameters;
        for (auto && name : moduleParamList.getParameterNames()) {
          filterParameters[name] = moduleParamList.getParameterDescription(name);
        }
 
        oss << quoted(filterName) << " :\n";
        if (filterParameters.empty()) {
          oss << "(no parameters)";
        } else {
          std::vector<std::string> parameterDescriptions;
          for (const auto& parameterNameAndDescription : filterParameters) {
            const std::string& parameterName = parameterNameAndDescription.first;
            const std::string& parameterDescription = parameterNameAndDescription.second;
            parameterDescriptions.push_back(parameterName + " -- " + parameterDescription);
          }
          oss << join(",\n", parameterDescriptions);
        }
        oss << ";\n";
      }
      return oss.str();
    }

◆ getDefaultFilterName()

const std::string & getDefaultFilterName

inherited

Legacy - Return the default filter suggested by the factory.

Definition at line 63 of file FilterFactory.icc.h.

    {
      return m_defaultFilterName;
    }

◆ getFilterPurpose()

std::string getFilterPurpose ( ) const

overridevirtual

Getter for a descriptive purpose of the constructed filters.

Reimplemented from TrackFilterFactory.

Definition at line 43 of file TrackQualityFilterFactory.cc.

{
  return "Track filter for getting the quality indicator for CDC tracks. It should "
         "distinguish correct PR tracks from fake and if wanted also clone tracks. ";
}

◆ getIdentifier()

std::string getIdentifier ( ) const

overridevirtualinherited

Getter for a short identifier for the factory.

Implements FilterFactory< BaseTrackFilter >.

Definition at line 44 of file TrackFilterFactory.cc.

{
  return "Track";
}

◆ getValidFilterNamesAndDescriptions()

std::map< std::string, std::string > getValidFilterNamesAndDescriptions ( ) const

overridevirtualinherited

Getter for valid filter names and a description for each.

Implements FilterFactory< BaseTrackFilter >.

Definition at line 55 of file TrackFilterFactory.cc.

{
  return {
    {"none", "no track is valid"},
    {"all", "set all tracks as good"},
    {"truth", "monte carlo truth"},
    {"recording", "record variables to a TTree"},
    {"recording_data", "record reco-variables to a TTree (no truth information)"},
    {"eval", "record truth and the mva response for insitu comparison"},
    {"mva", "test with a mva method"}
  };
}

Member Data Documentation

◆ m_defaultFilterName

std::string m_defaultFilterName

privateinherited

Legacy - Default filter name suggested by this factory.

Definition at line 67 of file FilterFactory.dcl.h.

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

tracking/trackFindingCDC/filters/track/include/TrackQualityFilterFactory.h
tracking/trackFindingCDC/filters/track/src/TrackQualityFilterFactory.cc

Public Types

Public Member Functions

Private Types

Private Attributes