GenParticleFilter::GenParticleFilter(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc)
{
declareProperty("accept", m_accept, {1});
declareInput("genparticles", m_iGenpHandle);
declareOutput("genparticles", m_oGenpHandle);
}
HepMCHistograms::HepMCHistograms(const std::string& name, ISvcLocator* svcLoc) :
GaudiAlgorithm(name, svcLoc), m_ths(nullptr),
m_pt(nullptr), m_eta(nullptr), m_d0(nullptr), m_z0(nullptr)
{
declareInput("hepmc", m_hepmchandle);
}
DelphesSimulation::DelphesSimulation(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc) ,
m_DelphesCard(),
m_Delphes(nullptr),
m_hepMCConverter(nullptr),
m_eventCounter(0),
m_outRootFile(nullptr),
m_outRootFileName(""),
m_treeWriter(nullptr),
m_branchEvent(nullptr),
m_confReader(nullptr),
m_allParticles(nullptr),
m_stableParticles(nullptr),
m_partons(nullptr)
{
//declareProperty("filename", m_filename="" , "Name of the HepMC file to read");
declareProperty("DelphesCard" , m_DelphesCard , "Name of Delphes tcl config file with detector and simulation parameters");
declareProperty("ROOTOutputFile" , m_outRootFileName , "Name of Delphes Root output file, if defined, the Delphes standard tree write out (in addition to FCC-EDM based output to transient data store)");
declareInput("hepmc", m_hepmcHandle);
declareProperty("outputs", m_saveToolNames);
declareOutput("genParticles" , m_handleGenParticles, "genParticles");
declareOutput("genVertices" , m_handleGenVertices, "genVertices");
}
CreateCaloCells::CreateCaloCells(const std::string& name, ISvcLocator* svcLoc)
: GaudiAlgorithm(name, svcLoc)
{
declareInput("hits", m_hits,"hits");
declareOutput("cells", m_cells,"cells");
declareProperty("mergeTool",m_mergeTool);
declarePrivateTool(m_mergeTool,"MergeCaloHitsTool");
declareProperty("calibTool",m_calibTool);
declarePrivateTool(m_calibTool,"CalibrateCaloHitsTool");
declareProperty("noiseTool",m_noiseTool);
declarePrivateTool(m_noiseTool,"NoiseCaloCellsTool");
declareProperty("doCellCalibration",m_doCellCalibration=true);
declareProperty("addCellNoise",m_addCellNoise=true);
declareProperty("filterCellNoise",m_filterCellNoise=false);
//PhiEta segmentation required
declareProperty("readoutName", m_readoutName="ECalHitsPhiEta");
declareProperty("activeVolumeName", m_activeVolumeName="LAr");
//number of volumes with active material which are not readout
declareProperty("numVolumesRemove",m_numVolumesRemove=0);
declareProperty("activeFieldName", m_activeFieldName="active_layer");
declareProperty("fieldNames", m_fieldNames);
declareProperty("fieldValues", m_fieldValues);
}
AudioOnsetsMarker::AudioOnsetsMarker() : Algorithm(), _beep(false) {
_preferredSize = 4096;
_onsetIdx = 0;
_processedSamples = 0;
_burstIdx = 0;
declareInput(_input, _preferredSize, "signal", "the input signal");
declareOutput(_output, _preferredSize, "signal", "the input signal mixed with bursts at onset locations");
}
CreatePositionedHit::CreatePositionedHit(const std::string& name, ISvcLocator* svcLoc)
: GaudiAlgorithm(name, svcLoc) {
declareInput("caloCells", m_caloCells,"caloCells");
declareOutput("caloPositionedHits", m_caloPositionedHits,"caloPositionedHits");
declareProperty("readoutName", m_readoutName="ECalHitsNew");
declareProperty("activeFieldName", m_activeFieldName="active_layer");
declareProperty("activeVolumeName", m_activeVolumeName="LAr_sensitive");
}
void Algorithm::declareInput(SinkBase& sink,
int acquireSize,
int releaseSize,
const std::string& name,
const std::string& desc) {
sink.setAcquireSize(acquireSize);
sink.setReleaseSize(releaseSize);
declareInput(sink, name, desc);
}
MergeCells::MergeCells(const std::string& aName, ISvcLocator* aSvcLoc):
GaudiAlgorithm(aName, aSvcLoc){
declareInput("inhits", m_inHits,"hits/caloInHits");
declareOutput("outhits", m_outHits,"hits/caloOutHits");
declareProperty("readout", m_readoutName);
declareProperty("identifier", m_idToMerge);
declareProperty("merge", m_numToMerge = 0);
declareProperty("debugPrint", m_debugPrint = 10);
}
Key::Key() : AlgorithmComposite() {
_keyAlgo = standard::AlgorithmFactory::create("Key");
_poolStorage = new PoolStorage<std::vector<Real> >(&_pool, "internal.hpcp");
declareInput(_poolStorage->input("data"), 1, "pcp", "the input pitch class profile");
declareOutput(_key, 0, "key", "the estimated key, from A to G");
declareOutput(_scale, 0, "scale", "the scale of the key (major or minor)");
declareOutput(_strength, 0, "strength", "the strength of the estimated key");
}
ChordsDetection::ChordsDetection() : AlgorithmComposite() {
declareInput(_pcp, "pcp", "the pitch class profile from which to detect the chord");
declareOutput(_chords, 1, "chords", "the resulting chords, from A to G");
declareOutput(_strength, 1, "strength", "the strength of the chord");
_chordsAlgo = standard::AlgorithmFactory::create("Key");
_chordsAlgo->configure("profileType", "tonictriad", "usePolyphony", false);
_poolStorage = new PoolStorage<vector<Real> >(&_pool, "internal.hpcp");
// FIXME: this is just a temporary hack...
// the correct way to do this is to have the algorithm output the chords
// continuously while processing, which requires a FrameCutter for vectors
// Need to set the buffer type to multiple frames as all the chords
// are output all at once
_chords.setBufferType(BufferUsage::forMultipleFrames);
_strength.setBufferType(BufferUsage::forMultipleFrames);
attach(_pcp, _poolStorage->input("data"));
}
ChordsDetection::ChordsDetection() : AlgorithmComposite() {
declareInput(_pcp, "pcp", "the pitch class profile from which to detect the chord");
declareOutput(_chords, 1, "chords", "the resulting chords, from A to G");
declareOutput(_strength, 1, "strength", "the strength of the chord");
_chordsAlgo = standard::AlgorithmFactory::create("Key");
_chordsAlgo->configure("profileType", "tonictriad", "usePolyphony", false);
_poolStorage = new PoolStorage<vector<Real> >(&_pool, "internal.hpcp");
// FIXME: this is just a temporary hack...
// the correct way to do this is to have the algorithm output the chords
// continuously while processing, which requires a FrameCutter for vectors
_chords.setBufferType(BufferUsage::forLargeAudioStream);
_strength.setBufferType(BufferUsage::forLargeAudioStream);
// Some old buffer settings that were not enough for long audio
//BufferInfo binfo;
//binfo.size = 16384;
//binfo.maxContiguousElements = 0;
//_chords.setBufferInfo(binfo);
//_strength.setBufferInfo(binfo);
attach(_pcp, _poolStorage->input("data"));
}
HepMCDumper::HepMCDumper(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc)
{
declareInput("hepmc", m_hepmchandle);
}
void Algorithm::declareInput(SinkBase& sink, int n,
const std::string& name, const std::string& desc) {
declareInput(sink, n, n, name, desc);
}
//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
G4ParticleCollectionTool::G4ParticleCollectionTool( const std::string& type,
const std::string& nam,const IInterface* parent )
: GaudiTool ( type, nam , parent )
{
declareInput("genParticles",m_genParticles, "allGenParticles");
}
DummySimulation::DummySimulation(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc) {
declareInput("genparticles", m_genphandle);
declareOutput("particles", m_recphandle);
}
Analyse::Analyse(const std::string& name, ISvcLocator* svcLoc):
GaudiAlgorithm(name, svcLoc) {
declareInput("particleassociation", m_partassociationhandle);
}
RingBufferOutput::RingBufferOutput() : _impl(0)
{
declareInput(_input, 1024, "signal", "the input signal that should go into the ringbuffer");
}
