int TRI_CreateKeyGenerator (const TRI_json_t* const parameters,
                            TRI_key_generator_t** dst) {
  TRI_key_generator_t* generator;
  const TRI_json_t* options;
  int res;

  *dst = NULL;

  options = NULL;
  if (parameters != NULL && parameters->_type == TRI_JSON_ARRAY) {
    options = parameters;
  }

  generator = CreateGenerator(options);

  if (generator == NULL) {
    return TRI_ERROR_ARANGO_INVALID_KEY_GENERATOR;
  }

  res = generator->init(generator, options);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_FreeKeyGenerator(generator);

    return res;
  }

  *dst = generator;

  return TRI_ERROR_NO_ERROR;
}
示例#2
0
XnStatus XnExportedSensorGenerator::Create(xn::Context& context, const XnChar* strInstanceName, const XnChar* strCreationInfo, xn::NodeInfoList* pNeededTrees, const XnChar* strConfigurationDir, xn::ModuleProductionNode** ppInstance)
{
    XnStatus nRetVal = XN_STATUS_OK;

    // needed trees should contain a device node
    if (pNeededTrees == NULL || pNeededTrees->Begin() == pNeededTrees->End())
    {
        return XN_STATUS_MISSING_NEEDED_TREE;
    }

    xn::NodeInfo deviceInfo = *(pNeededTrees->Begin());
    if (deviceInfo.GetDescription().Type != XN_NODE_TYPE_DEVICE)
    {
        return XN_STATUS_MISSING_NEEDED_TREE;
    }

    // Get the sensor instance
    xn::Device device;
    nRetVal = deviceInfo.GetInstance(device);
    XN_IS_STATUS_OK(nRetVal);

    XnDeviceBase* pSensor = NULL;
    nRetVal = device.GetGeneralProperty(XN_SENSOR_PROPERTY_INSTANCE_POINTER, sizeof(XnDeviceBase*), &pSensor);
    XN_IS_STATUS_OK(nRetVal);

    // create stream
    nRetVal = pSensor->CreateStream(m_strStreamType, strInstanceName);
    XN_IS_STATUS_OK(nRetVal);

    // create generator
    XnSensorGenerator* pGenerator = CreateGenerator(context, device, pSensor, strInstanceName);
    if (pGenerator == NULL)
    {
        pSensor->DestroyStream(strInstanceName);
        return (XN_STATUS_ALLOC_FAILED);
    }

    // and initialize it
    nRetVal = pGenerator->Init();
    if (nRetVal != XN_STATUS_OK)
    {
        pSensor->DestroyStream(strInstanceName);
        XN_DELETE(pGenerator);
        return (nRetVal);
    }

    *ppInstance = pGenerator;

    return (XN_STATUS_OK);
}
示例#3
0
void fastGenPA(Int_t nev = 1, char* filename = "gilc.root")
{
//  Runloader
    IlcRunLoader* rl = IlcRunLoader::Open("gilc.root", "FASTRUN", "recreate");

    rl->SetCompressionLevel(2);
    rl->SetNumberOfEventsPerFile(10000);
    rl->LoadKinematics("RECREATE");
    rl->MakeTree("E");
    gIlc->SetRunLoader(rl);


//  Create stack
    rl->MakeStack();
    IlcStack* stack      = rl->Stack();
 
//  Header
    IlcHeader* header = rl->GetHeader();


//  Create and Initialize Generator
    IlcGenerator *gener = CreateGenerator();
    gener->Init();
    gener->SetStack(stack);
    
//
//                        Event Loop
//
    Int_t iev;
     
    for (iev = 0; iev < nev; iev++) {

	printf("\n \n Event number %d \n \n", iev);

	//  Initialize event

	header->Reset(0,iev);
	rl->SetEventNumber(iev);
	stack->Reset();
	rl->MakeTree("K");

//  Generate event

	gener->Generate();

//  Analysis
	Int_t npart = stack->GetNprimary();
	printf("Analyse %d Particles\n", npart);
	for (Int_t part=0; part<npart; part++) {
	    TParticle *MPart = stack->Particle(part);
	    Int_t mpart  = MPart->GetPdgCode();
	}
	
//  Finish event
	header->SetNprimary(stack->GetNprimary());
	header->SetNtrack(stack->GetNtrack());  
//      I/O
//	
	stack->FinishEvent();
	header->SetStack(stack);
	rl->TreeE()->Fill();
	rl->WriteKinematics("OVERWRITE");
    } // event loop
//
//                         Termination
//  Generator
    gener->FinishRun();

    //  Write file
    rl->WriteHeader("OVERWRITE");
    gener->Write();
    rl->Write();
}
示例#4
0
文件: fastGen.C 项目: ktf/AliPhysics
void fastGen(Tune_t tune = kPyTuneCDFA , Float_t energy, Int_t nev = 1, TString process)
{
  // Add all particles to the PDG database
  AliPDG::AddParticlesToPdgDataBase();

  // set the random seed
  TDatime date;
  UInt_t seed    = date.Get()+gSystem->GetPid();
  gRandom->SetSeed(seed);
  cout<<"Seed for random number generation= "<<seed<<endl; 


  //  Runloader  
  AliRunLoader* rl = AliRunLoader::Open("galice.root", "FASTRUN","recreate");
    
  rl->SetCompressionLevel(2);
  rl->SetNumberOfEventsPerFile(nev);
  rl->LoadKinematics("RECREATE");
  rl->MakeTree("E");
  gAlice->SetRunLoader(rl);

  //  Create stack
  rl->MakeStack();
  AliStack* stack      = rl->Stack();
 
  //  Header
  AliHeader* header = rl->GetHeader();
  //
  //  Create and Initialize Generator
  AliGenerator *gener = CreateGenerator(tune,energy);
  gener->Init();
  // if nsd switch off single diffraction
  if ( process == "NSD"){
    if(tune != kPhojet) {
      AliPythia::Instance()->	SetMSUB(92,0);             // single diffraction AB-->XB
      AliPythia::Instance()-> SetMSUB(93,0);             // single diffraction AB-->AX
    }
    else {
      cout << "NSD not yet implemented in the phojet case" << endl;
      exit(1);
    }
  }
  gener->SetStack(stack);
    
  //
  //                        Event Loop
  //
  Int_t iev;
     
  for (iev = 0; iev < nev; iev++) {

    if(!(iev%500)) printf("\n \n Event number %d \n \n", iev);
	
    //  Initialize event
    header->Reset(0,iev);
    rl->SetEventNumber(iev);
    stack->Reset();
    rl->MakeTree("K");
    //	stack->ConnectTree();
    
    //  Generate event
    gener->Generate();
    //  Analysis
    // 	Int_t npart = stack->GetNprimary();
    // 	printf("Analyse %d Particles\n", npart);
    // 	for (Int_t part=0; part<npart; part++) {
    // 	    TParticle *MPart = stack->Particle(part);
    // 	    Int_t mpart  = MPart->GetPdgCode();
    // 	    printf("Particle %d\n", mpart);
    // 	}
	
    //  Finish event
    header->SetNprimary(stack->GetNprimary());
    header->SetNtrack(stack->GetNtrack());  
    //      I/O
    //	
    stack->FinishEvent();
    header->SetStack(stack);
    rl->TreeE()->Fill();
    rl->WriteKinematics("OVERWRITE");

  } // event loop
    //
    //                         Termination
    //  Generator
  gener->FinishRun();
  //  Write file
  rl->WriteHeader("OVERWRITE");
  gener->Write();
  rl->Write();
    
}