mitk::Mapper::Pointer mitk::DiffusionCoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
  mitk::Mapper::Pointer newMapper=NULL;

  if ( id == mitk::BaseRenderer::Standard2D )
  {
    std::string classname("QBallImage");
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::CompositeMapper::New();
      newMapper->SetDataNode(node);
      node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
    }
    classname = "TensorImage";
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::CompositeMapper::New();
      newMapper->SetDataNode(node);
      node->SetMapper(3, ((CompositeMapper*)newMapper.GetPointer())->GetImageMapper());
    }

    classname = "DiffusionImage";
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::DiffusionImageMapper<short>::New();
      newMapper->SetDataNode(node);
    }

  }
  else if ( id == mitk::BaseRenderer::Standard3D )
  {
    std::string classname("QBallImage");
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::GPUVolumeMapper3D::New();
      newMapper->SetDataNode(node);
    }
    classname = "TensorImage";
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::GPUVolumeMapper3D::New();
      newMapper->SetDataNode(node);
    }
    classname = "DiffusionImage";
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::GPUVolumeMapper3D::New();
      newMapper->SetDataNode(node);
    }
  }

  return newMapper;
}
예제 #2
0
void mitk::SegmentationObjectFactory::SetDefaultProperties(mitk::DataNode* node)
{

  if(node==NULL)
    return;

  mitk::DataNode::Pointer nodePointer = node;

  std::string classname("ContourModel");
  if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
  {
    mitk::ContourModelGLMapper2D::SetDefaultProperties(node);
    mitk::ContourModelMapper3D::SetDefaultProperties(node);
  }

//  mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
//  if(image.IsNotNull() && image->IsInitialized())
//  {
//    mitk::GPUVolumeMapper3D::SetDefaultProperties(node);
//  }
//
//  if (dynamic_cast<mitk::UnstructuredGrid*>(node->GetData()))
//  {
//    mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(node);
//  }

}
예제 #3
0
size_t TestFixture::runTests(const char cmd[])
{
    std::string classname(cmd ? cmd : "");
    std::string testname("");
    if (classname.find("::") != std::string::npos)
    {
        testname = classname.substr(classname.find("::") + 2);
        classname.erase(classname.find("::"));
    }

    countTests = 0;
    errmsg.str("");

    const std::list<TestFixture *> &tests = TestRegistry::theInstance().tests();

    for (std::list<TestFixture *>::const_iterator it = tests.begin(); it != tests.end(); ++it)
    {
        if (classname.empty() || (*it)->classname == classname)
        {
            (*it)->run(testname);
        }
    }

    std::cout << "\n\nTesting Complete\nNumber of tests: " << countTests << "\n";

    std::cerr << errmsg.str();

    return fails_counter;
}
예제 #4
0
파일: dump.c 프로젝트: bhanug/harvey
int
Ufmt(Fmt *f)
{
	int i;
	Dev *d;
	Usbdev *ud;
	char buf[1024];
	char *s, *e;

	s = buf;
	e = buf+sizeof(buf);
	d = va_arg(f->args, Dev*);
	if(d == nil)
		return fmtprint(f, "<nildev>\n");
	s = seprint(s, e, "%s", d->dir);
	ud = d->usb;
	if(ud == nil)
		return fmtprint(f, "%s %ld refs\n", buf, d->Ref.ref);
	s = seprint(s, e, " csp %s.%uld.%uld",
		classname(Class(ud->csp)), Subclass(ud->csp), Proto(ud->csp));
	s = seprint(s, e, " vid %#ux did %#ux", ud->vid, ud->did);
	s = seprint(s, e, " refs %ld\n", d->Ref.ref);
	s = seprint(s, e, "\t%s %s %s\n", ud->vendor, ud->product, ud->serial);
	for(i = 0; i < Nconf; i++){
		if(ud->conf[i] == nil)
			break;
		else
			s = seprintconf(s, e, ud, i);
	}
	return fmtprint(f, "%s", buf);
}
예제 #5
0
void ParameterWidget::setSavedFilters(int defaultId)
{
  QString query;
  XSqlQuery qry;

  if(this->parent())
  {
    const QMetaObject *metaobject = this->parent()->metaObject();
    QString classname(metaobject->className());

    query = " SELECT 0 AS filter_id, :none AS filter_name, 1 AS seq "
            " UNION "
            " SELECT filter_id, filter_name, 2 AS seq "
            " FROM filter "
            " WHERE filter_username=current_user "
            " AND filter_screen=:screen "
            " ORDER BY seq, filter_name ";

    qry.prepare(query);

    qry.bindValue(":screen", classname);
    qry.bindValue(":none", tr("None"));
    qry.exec();
    if (defaultId)
      _filterList->populate(qry, defaultId);
    else
      _filterList->populate(qry, 0);
  }
}
예제 #6
0
std::size_t TestFixture::runTests(const options& args)
{
    std::string classname(args.which_test());
    std::string testname("");
    if (classname.find("::") != std::string::npos) {
        testname = classname.substr(classname.find("::") + 2);
        classname.erase(classname.find("::"));
    }

    countTests = 0;
    errmsg.str("");

    const std::list<TestFixture *> &tests = TestRegistry::theInstance().tests();

    for (std::list<TestFixture *>::const_iterator it = tests.begin(); it != tests.end(); ++it) {
        if (classname.empty() || (*it)->classname == classname) {
            (*it)->processOptions(args);
            (*it)->run(testname);
        }
    }

    std::cout << "\n\nTesting Complete\nNumber of tests: " << countTests << std::endl;
    std::cout << "Number of todos: " << todos_counter;
    if (succeeded_todos_counter > 0)
        std::cout << " (" << succeeded_todos_counter << " succeeded)";
    std::cout << std::endl;
    // calling flush here, to do all output before the error messages (in case the output is buffered)
    std::cout.flush();

    std::cerr << "Tests failed: " << fails_counter << std::endl << std::endl;
    std::cerr << errmsg.str();
    std::cerr.flush();
    return fails_counter;
}
예제 #7
0
VALUE
rb_class_path(VALUE klass)
{
    VALUE path = classname(klass);
    st_data_t n = (st_data_t)path;

    if (!NIL_P(path)) return path;
    if (RCLASS_IV_TBL(klass) && st_lookup(RCLASS_IV_TBL(klass),
					  (st_data_t)tmp_classpath, &n)) {
	return (VALUE)n;
    }
    else {
	const char *s = "Class";

	if (TYPE(klass) == T_MODULE) {
	    if (rb_obj_class(klass) == rb_cModule) {
		s = "Module";
	    }
	    else {
		s = rb_class2name(RBASIC(klass)->klass);
	    }
	}
	path = rb_sprintf("#<%s:%p>", s, (void*)klass);
	OBJ_FREEZE(path);
	rb_ivar_set(klass, tmp_classpath, path);

	return path;
    }
}
예제 #8
0
파일: variable.c 프로젝트: kyab/MacRuby
VALUE
rb_class_path(VALUE klass)
{
    VALUE path = classname(klass);

    if (!NIL_P(path)) {
	return path;
    }
    if ((path = rb_attr_get(klass, id_tmp_classpath)) != Qnil) {
	return path;
    }
    else {
	const char *s = "Class";

	if (TYPE(klass) == T_MODULE) {
	    if (rb_obj_class(klass) == rb_cModule) {
		s = "Module";
	    }
	    else {
		s = rb_class2name(RBASIC(klass)->klass);
	    }
	}
	path = rb_sprintf("#<%s:%p>", s, (void*)klass);
	OBJ_FREEZE(path);
	rb_ivar_set(klass, id_tmp_classpath, path);

	return path;
    }
}
예제 #9
0
mitk::Mapper::Pointer mitk::SegmentationObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
{
  mitk::Mapper::Pointer newMapper=NULL;
  mitk::BaseData *data = node->GetData();

  if ( id == mitk::BaseRenderer::Standard2D )
  {
    if((dynamic_cast<Contour*>(data)!=NULL))
    {
      newMapper = mitk::ContourMapper2D::New();
      newMapper->SetDataNode(node);
    }
    else if((dynamic_cast<ContourSet*>(data)!=NULL))
    {
      newMapper = mitk::ContourSetMapper2D::New();
      newMapper->SetDataNode(node);
    }

    std::string classname("ContourModel");
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::ContourModelGLMapper2D::New();
      newMapper->SetDataNode(node);
    }
  }
  else if ( id == mitk::BaseRenderer::Standard3D )
  {
    if((dynamic_cast<Contour*>(data)!=NULL))
    {
      newMapper = mitk::ContourVtkMapper3D::New();
      newMapper->SetDataNode(node);
    }
    else if((dynamic_cast<ContourSet*>(data)!=NULL))
    {
      newMapper = mitk::ContourSetVtkMapper3D::New();
      newMapper->SetDataNode(node);
    }

    std::string classname("ContourModel");
    if(node->GetData() && classname.compare(node->GetData()->GetNameOfClass())==0)
    {
      newMapper = mitk::ContourModelMapper3D::New();
      newMapper->SetDataNode(node);
    }
  }
  return newMapper;
}
예제 #10
0
void 
MethodCallBase::unsupported() 
{
	rb_raise(rb_eArgError, "Cannot handle '%s' as argument of %s::%s",
		type().name(),
		classname(),
		_smoke->methodNames[method().name]);
}
예제 #11
0
void 
MethodReturnValueBase::unsupported() 
{
	rb_raise(rb_eArgError, "Cannot handle '%s' as return-type of %s::%s",
	type().name(),
	classname(),
	_smoke->methodNames[method().name]);	
}
예제 #12
0
VALUE
rb_mod_name(VALUE mod)
{
    VALUE path = classname(mod);

    if (!NIL_P(path)) return rb_str_dup(path);
    return path;
}
예제 #13
0
void ParameterWidget::applyDefaultFilterSet()
{
  XSqlQuery qry;
  QString filter_name;
  int filter_id;
	QString pname;

 

  //hides parameterwidget when it's embedded within another widget with a parent
  if (this->parent() && this->parent()->parent())
  {
    clearFilters();
    this->hide();

    return;
  }

	if(window())
    pname = window()->objectName() + "/";
	_settingsName2 = pname + this->objectName();

	if(_x_preferences)
  {
		_settingsName2 += "/filter_default";
		filter_id = _x_preferences->value(_settingsName2).toInt();
	}

  QString query = "SELECT filter_name "
                  "FROM filter "
                  "WHERE filter_id=:id ";
                  

  if (this->parent())
  {
    QString classname(parent()->objectName());
    if (classname.isEmpty())
      classname = parent()->metaObject()->className();

    qry.prepare(query);
		qry.bindValue(":id", filter_id);
    qry.exec();

    if (qry.first())
    {
      filter_name = qry.value("filter_name").toString();
      setSavedFiltersIndex(filter_name);
      applySaved(0, filter_id);
    }
    else
    {
      addParam();
			applySaved(0, 0);
    }

  }

}
void ElectronMuonCandidateMaker::initialize(){
	CandidateMaker::initialize();
	
	if ( !config.exists( nodePath + ".MuonCandidateCuts" ) ){
		ERROR( classname(), "Cannot find **required** MuonCandidateCuts" );
		chain = nullptr;
		return;
	}
	muonCuts.init( config, nodePath + ".MuonCandidateCuts" );
	INFO( classname(), "" );
	INFO( classname(), "############### Muon Cuts ###################"  );
	muonCuts.report();
	INFO( classname(), "" );

	electronCuts.init( config, nodePath + ".ElectronCandidateCuts" );
	electronCuts.setDefault( "pt", 0.1, 10000 );
	electronCuts.setDefault( "nHitsDedx", 10, 10000 );
	electronCuts.setDefault( "nHitsRatio", 0.52, 100 );
	electronCuts.setDefault( "eta", -0.8, 0.8 );
	electronCuts.setDefault( "nSigmaPion", -1.5, 1.5 );
	electronCuts.setDefault( "matchFlagEmc", 1, 100 );
	INFO( classname(), "" );
	INFO( classname(), "############### Electron Cuts ###################"  );
	electronCuts.report();
	INFO( classname(), "" );

	gErrorIgnoreLevel = kBreak;

}
예제 #15
0
Object Registry::NewFromClassName(const char *classname_str)
{
    Label classname(classname_str);
    const ClassBase *klass = GetClass(classname);
    if (klass == 0)
        KAI_THROW_1(UnknownClass<>, String(classname_str));

    return NewFromClass(klass);
}
예제 #16
0
void FeedDownMaker::initialize(){
		TreeAnalyzer::initialize();
	DEBUG( classname(), "" );
	if ( ds && ds->getTreeName() == "StMiniMcTree" ){
		INFO( classname(), "Using DataStore" )
	} else {
		ERROR( classname(), "No Data Source. Specify one at <DataSourcce ... > </DataSource>" )
	}

	

	// map of GEANT PID -> histogram name
	plcName[ 8 ] = "Pi_p";
	plcName[ 9 ] = "Pi_n";
	plcName[ 11 ] = "K_p";
	plcName[ 12 ] = "K_n";
	plcName[ 14 ] = "P_p";
	plcName[ 15 ] = "P_n";


	// Tracks cuts
	cut_nHitsFit             = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.nHitsFit"             , 0     , std::numeric_limits<int>::max() ) );
	cut_dca                  = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.dca"                  , 0     , std::numeric_limits<int>::max() ) );
	cut_nHitsFitOverPossible = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.nHitsFitOverPossible" , 0     , std::numeric_limits<int>::max() ) );
	cut_nHitsDedx            = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.nHitsDedx"            , 0     , std::numeric_limits<int>::max() ) );
	cut_pt                   = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.pt"                   , 0     , std::numeric_limits<int>::max() ) );
	cut_ptGlobalOverPrimary  = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.ptGlobalOverPrimary"  , 0.7   , 1.42 ) );
	cut_rapidity             = unique_ptr<XmlRange>(new XmlRange( &config , "TrackCuts.rapidity"             , -0.25 , 	0.25 ) );

	formulas =	{ "[0]*exp( -[1] * x ) + [2] * exp( -[3] * x )",
				"[0]*exp( -[1] * x ) + [2] * exp( -[3] * x )",
				"[0]*exp( -[1] * x ) + [2] * exp( -[3] * x )",
				"[0]*exp( -[1] * x ) + [2] * exp( -[3] * x )",
				"[0]*exp( -[1] * x ) + [2] * exp( -[3] * x * x )",
				"(1-[0]*exp( -[1] * x ) ) * [2] * exp( -[3] * x )" };

	rmb = unique_ptr<HistoBins>( new HistoBins( config, nodePath + ".RefMultBins" ) );

	// Setup the centrality bins
   	INFO( classname(), "Loading Centrality Map" ); 
    centralityBinMap = config.getIntMap( nodePath + ".CentralityMap" );
    centralityBins = config.getIntVector( nodePath + ".CentralityBins" );
    INFO( classname(), "c[ 0 ] = " << centralityBinMap[ 0 ] );
}
예제 #17
0
파일: variable.c 프로젝트: kyab/MacRuby
VALUE
rb_mod_name(VALUE mod, SEL sel)
{
    VALUE path = classname(mod);

    if (!NIL_P(path)) {
	return rb_str_dup(path);
    }
    return path;
}
예제 #18
0
파일: filter.cpp 프로젝트: timepp/tplog
bool logcontent_filter::save(component_creator* /*cc*/, serializer* s) const
{
	serializer* mys = s->add_child(classname());

	mys->set_property(L"matcher", m_matcher.c_str());
	mys->set_property(L"ignorecase", formatstr(L"%d", m_ignore_case? 1: 0));
	mys->set_property(L"useregex", formatstr(L"%d", m_use_regex? 1: 0));

	return true;
}
예제 #19
0
파일: filter.cpp 프로젝트: timepp/tplog
bool logtid_filter::save(component_creator *, serializer *s) const
{
#ifdef SAVE_UNSTABLE_FILTER
	serializer* mys = s->add_child(classname());
	mys->set_property(L"tid", (const wchar_t*)tp::cz(L"%u", m_tid));
	return true;
#else
	return false;
#endif
}
예제 #20
0
파일: cxxUtils.cpp 프로젝트: cran/cxxPack
    template<> SEXP wrap<RcppDatetime>(const RcppDatetime& date) {
	Rcpp::NumericVector value(1);
	Rcpp::CharacterVector classname(2);
	value[0] = date.getFractionalTimestamp();
	Rcpp::RObject robj((SEXP)value);
	classname[0] = Rcpp::datetimeClass[0];
	classname[1] = Rcpp::datetimeClass[1];
	robj.attr("class") = classname;
	return value;
    }
예제 #21
0
void BinaryInFileBuf::load(){
    if(!this->_closed){
        size_t sz = fread(_buf,1,BUF_SZ,this->_pIn);
        if(sz < BUF_SZ || feof(_pIn))
            this->_done = true;
        if(ferror(_pIn))
            throw std::runtime_error(classname() + "invalid file state when reading file");
        this->_end = sz;
        this->_cur = 0;
    }
}
예제 #22
0
 const Entity::RotationInfo Entity::rotationInfo() const {
     RotationType type = RTNone;
     PropertyKey property;
     
     // determine the type of rotation to apply to this entity
     const String* classn = classname();
     if (classn != NULL) {
         if (Utility::startsWith(*classn, "light")) {
             if (propertyForKey(MangleKey) != NULL) {
                 // spotlight without a target, update mangle
                 type = RTEulerAngles;
                 property = MangleKey;
             } else if (propertyForKey(TargetKey) == NULL) {
                 // not a spotlight, but might have a rotatable model, so change angle or angles
                 if (propertyForKey(AnglesKey) != NULL) {
                     type = RTEulerAngles;
                     property = AnglesKey;
                 } else {
                     type = RTZAngle;
                     property = AngleKey;
                 }
             } else {
                 // spotlight with target, don't modify
             }
         } else {
             bool brushEntity = !m_brushes.empty() || (m_definition != NULL && m_definition->type() == EntityDefinition::BrushEntity);
             if (brushEntity) {
                 if (propertyForKey(AnglesKey) != NULL) {
                     type = RTEulerAngles;
                     property = AnglesKey;
                 } else if (propertyForKey(AngleKey) != NULL) {
                     type = RTZAngleWithUpDown;
                     property = AngleKey;
                 }
             } else {
                 // point entity
                 
                 // if the origin of the definition's bounding box is not in its center, don't apply the rotation
                 const Vec3f offset = origin() - center();
                 if (offset.x() == 0.0f && offset.y() == 0.0f) {
                     if (propertyForKey(AnglesKey) != NULL) {
                         type = RTEulerAngles;
                         property = AnglesKey;
                     } else {
                         type = RTZAngle;
                         property = AngleKey;
                     }
                 }
             }
         }
     }
     
     return RotationInfo(type, property);
 }
예제 #23
0
void UrQMDDcaMapMaker::preEventLoop(){
	DEBUG( classname(), "" );
	TreeAnalyzer::preEventLoop();

	string sCharge = config.getXString( nodePath + ".input:charge", "p" );
	string plc     = config.getXString( nodePath + ".input:plc", "Pi" );
	book->cd();
	// for ( int iC : centralityBins ){
	// 	INFO( classname(), "urqmd_dca_vs_pt_" + plc + "_" + ts( iC ) + "_" + sCharge );
	// 	book->clone( "dca_vs_pt", "urqmd_dca_vs_pt_" + plc + "_" + ts( iC ) + "_" + sCharge );
	// }

	for ( string plc : { "Pi", "K", "P" } ){
		for ( string charge : { "p", "n" } ){
			INFO( classname(), "Making : " << "urqmd_dca_vs_pt_" + plc + "_" + charge  );
			book->clone( "dca_vs_pt", "urqmd_dca_vs_pt_" + plc + "_" + charge );
		}
	}
	
}
예제 #24
0
BinaryInFileBuf::BinaryInFileBuf(FILE* in)
{
    this->init();
    this->_pIn = in;
    if(!in){
        this->nultify();
        cerr<<classname()<<"invalid file handler!"<<endl;
        cerr.flush();
    }
    else
        this->load();
}
예제 #25
0
파일: filter.cpp 프로젝트: timepp/tplog
bool logclass_filter::save(component_creator* /*cc*/, serializer* s) const
{
	wchar_t buf[32];
	serializer* mys = s->add_child(classname());
	swprintf_s(buf, L"%u", m_class_low);
	mys->set_property(L"class_low", buf);

	swprintf_s(buf, L"%u", m_class_high);
	mys->set_property(L"class_high", buf);

	return true;
}
예제 #26
0
파일: CBBOC2015.hpp 프로젝트: altoplano/cpp
	static void run( Competitor& client )	{

		const std::string root = "./resources/";
		const std::string problemClassFile = root + "classFolder.txt";

		const std::vector< std::string > lines = read_text_file( problemClassFile );
		if( lines.empty() )
			throw std::runtime_error( "bad format for classFolder.txt" );

		const std::string problemClassName = lines.front();
		const std::string problemFolder( root + problemClassName );
		ProblemClass problemClass( problemFolder, client.getTrainingCategory() );
		
		long long actualTestingTime = -1, actualTrainingTime = -1;

		switch( client.getTrainingCategory() ) {
			case TrainingCategory::NONE : {
				actualTestingTime = testClient( client, problemClass.getTestingInstances() );
				std::clog << "actualTestingTime:" << actualTestingTime << std::endl;
			} break;
			case TrainingCategory::SHORT :
			case TrainingCategory::LONG : {
				actualTrainingTime = trainClient( client, problemClass.getTrainingInstances() );
				std::clog <<"actualTrainingTime:" << actualTrainingTime << std::endl;
				
				actualTestingTime = testClient( client, problemClass.getTestingInstances() );
				std::clog <<"actualTestingTime:" << actualTestingTime << std::endl;	
			} break;
			default : 
				throw std::logic_error( "Bad training category in CBBOC2015.run()" );
		}

		///////////////////////////

		const std::time_t now = std::time(NULL);
		char buffer[ 1024 ];
		std::strftime( buffer, sizeof(buffer), "%Y-%m-%d-%H-%M-%S", // "%T",
			std::localtime(&now));

		const std::string timestamp( buffer );

		const std::string className = classname( client );
		OutputResults results( className, timestamp, problemClassName, problemClass, actualTrainingTime, actualTestingTime );

		std::string outputPath = problemFolder + "/results/";
		outputPath += "CBBOC2015results-" + className + "-" + problemClassName + "-" + timestamp + ".json";
		std::ofstream out( outputPath );
		out << results.toJSonString() << std::endl;

		///////////////////////////

		std::cout << results.toJSonString() << std::endl;
	}
예제 #27
0
파일: Reporter.cpp 프로젝트: jdbrice/boiler
	Reporter::Reporter( XmlConfig &config, string np, string prefix ){
		DEBUG( classname(), "( config, np=" << np << ", prefix=" << prefix << ")" )

		this->config = config;
		this->nodePath = config.basePath( np );

		this->filename = prefix + config.getString( nodePath + ".output:url" );

		int w = config.getInt( nodePath + ".output:width", 400 );
		int h = config.getInt( nodePath + ".output:height", 400 );

		canvas = new TCanvas( ("Reporter" + ts( instances ) ).c_str() , "canvas", w, h);
		canvas->Print( ( filename + "[" ).c_str() );
		
		DEBUG( classname(), " Opening " << filename ) 
		
		instances++;

		isOpen = true;

		DEBUG( classname(), " Instance #" << instances )
	}
예제 #28
0
	void HistoAnalyzer::initReporter( string _jobPostfix ){

		INFO( classname(), "Creating Reporter" );
		string pRepOut = config.join( nodePath, "Reporter", "output:url" );
		string outputURL = config[ pRepOut ];

	   	// Default reporter
	   	// dont make for parallel!
	    if ( ".root" == _jobPostfix && config.exists( pRepOut ) ) {
		    reporter = shared_ptr<Reporter>(
		    	new Reporter( 	config, 
		    					config.join( nodePath, "Reporter" ), 
		    					"" 
		    				) 
		    	); // TODO: is reporter's path handeling broken?

		    INFO( classname(), "Creating report @" << outputURL );
	    } else {
	    	INFO( classname(), "No Reporter created, jobPostfix == " << _jobPostfix );
			reporter = nullptr;
	    }
	}
bool ElectronMuonCandidateMaker::keepTrack( int iTrack ){
	DEBUG( classname(), fmt::format( "(iTrack={0})", iTrack ) );

	isElectron = CandidateFilter::isElectron( pico, iTrack, electronCuts );
	isMuon = CandidateFilter::isMuon( pico, iTrack, muonCuts );
	
	if ( isElectron )
		nElectrons ++;
	if ( isMuon )
		nMuons ++;

	return ( isElectron || isMuon );
 	return true;
}
예제 #30
0
파일: parser2.c 프로젝트: tungvx/FSE
static AST classhead() {
    Token *t = &tok;
    AST a=0;
    AST a1=0, a2=0;

    if (t->sym == tCLASS) {
	gettoken();
	a1 = classname();
	if (a1) {
	    insert_SYM(get_text(a1), 0, tGLOBAL, 0); /* dummy */
	}
	a  = make_AST(nCLASSHEAD, a1, 0, 0, 0);
    } else {
	parse_error("expected class");
    }
    return a;
}