void DecisionTree::train (const vector<TrainingExample*>& examples, const vector<double>& weights) { // cerr << "Training tree with " << examples.size() << " training examples\n"; // cerr << "Tree max-depth used: " << getMaxDepth() << endl; // cerr << "Classification threshold used: " << getClassificationThreshold() << endl; if(m_root) { delete m_root; m_root = 0; } m_feature_thresholds.clear(); assert(examples.size()>0); size_t num_features = examples[0]->getNumberOfFeatures(); double sum_weights = sumWeights(weights); // compute feature averages that we shall use as thresholds... vector<double> feature_averages; // cerr << "Number of examples: " << num_examples << ", Number of features: " << num_features << endl; feature_averages.resize(num_features,0.0); for(size_t ie=0; ie<examples.size(); ++ie) { // cerr << "Processing example: " << ie << endl; const TrainingExample* ex = examples[ie]; // cerr << "Number of features: " << examples[ie]->getNumberOfFeatures() << endl; assert(ex->getNumberOfFeatures()==num_features); for(size_t ifeat=0; ifeat<num_features; ifeat++) { // cerr << "Feature: " << ifeat << ", value: " << ex->getFeatureDoubleValue(ifeat); double fv = ex->getFeatureDoubleValue(ifeat); feature_averages[ifeat]+=fv*weights[ie]; } } // cerr << "Average thresholds:\n"; for(size_t ifeat=0; ifeat<num_features; ifeat++) { feature_averages[ifeat]/=sum_weights; // cerr << ifeat << ": " << feature_averages[ifeat] << "\t"; } m_feature_thresholds = feature_averages; // cerr << "Recursive train tree:\n"; set<size_t> empty_used_features; m_root = recursiveTrainTree(examples,weights,sum_weights,empty_used_features); // printTree(); }
list<ElementData*> * Game::testWind(Map & map, Wind & wind) { list<ElementData*> * toDestroy = new list<ElementData*>; TYP sum = sumWeights(map); TYP dir,force; wind.getWind(dir,force); int i=1; for(i; i<_highestBlock+1 && sum-force>0; i++) sum-=force; if(i<_highestBlock) //To oznacza, ze wiatr nie zostal zamortyzowany { for(int k = i; k<=_highestBlock; k++) //chodzenie po wysokosciach { bool breaker = false; if(dir==WIND_RIGHT_DIR) { for(int j=0; j<map.getWidth() && !breaker; j++) if(map(j,i,DIM_WHO_TAB)!=EMPTY) { toDestroy->push_back(&map(j,k)); breaker = true; } } else { for(int j=map.getWidth()-1; j>=0 && !breaker; j--) if(map(j,i,DIM_WHO_TAB)!=EMPTY) { toDestroy->push_back(&map(j,k)); breaker = true; } } } } return toDestroy; }
l1menu::ReducedSamplePrivateMembers::ReducedSamplePrivateMembers( const l1menu::ReducedSample& thisObject, const std::string& filename ) : event(thisObject), triggerMenu(mutableTriggerMenu_), eventRate(1), sumOfWeights(0) { GOOGLE_PROTOBUF_VERIFY_VERSION; // Open the file with read ability int fileDescriptor = open( filename.c_str(), O_RDONLY ); if( fileDescriptor==0 ) throw std::runtime_error( "ReducedSample initialise from file - couldn't open file" ); ::UnixFileSentry fileSentry( fileDescriptor ); // Use this as an exception safe way of closing the input file google::protobuf::io::FileInputStream fileInput( fileDescriptor ); // First read the magic number at the start of the file and make sure it // matches what I expect. This is uncompressed so I'll wrap it in a block // to make sure the CodedInputStream is destructed before creating a new // one with gzip input. { google::protobuf::io::CodedInputStream codedInput( &fileInput ); // As a read buffer, I'll create a string the correct size (filled with an arbitrary // character) and read straight into that. std::string readMagicNumber; if( !codedInput.ReadString( &readMagicNumber, FILE_FORMAT_MAGIC_NUMBER.size() ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading magic number" ); if( readMagicNumber!=FILE_FORMAT_MAGIC_NUMBER ) throw std::runtime_error( "ReducedSample - tried to initialise with a file that is not the correct format" ); google::protobuf::uint32 fileformatVersion; if( !codedInput.ReadVarint32( &fileformatVersion ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading file format version" ); // So far I only have (and ever expect to have) one version of the file // format, imaginatively versioned "1". You never know though... if( fileformatVersion>1 ) std::cerr << "Warning: Attempting to read a ReducedSample with version " << fileformatVersion << " with code that only knows up to version 1." << std::endl; } google::protobuf::io::GzipInputStream gzipInput( &fileInput ); google::protobuf::io::CodedInputStream codedInput( &gzipInput ); // Disable warnings on this input stream (second parameter, -1). The // first parameter is the default. I'll change this if necessary in // the loop later. size_t totalBytesLimit=67108864; codedInput.SetTotalBytesLimit( totalBytesLimit, -1 ); google::protobuf::uint64 messageSize; // Read the size of the header message if( !codedInput.ReadVarint64( &messageSize ) ) throw std::runtime_error( "ReducedSample initialise from file - error reading message size for header" ); google::protobuf::io::CodedInputStream::Limit readLimit=codedInput.PushLimit(messageSize); if( !protobufSampleHeader.ParseFromCodedStream( &codedInput ) ) throw std::runtime_error( "ReducedSample initialise from file - some unknown error while reading header" ); codedInput.PopLimit(readLimit); // Keep looping until there is nothing more to be read from the file. while( codedInput.ReadVarint64( &messageSize ) ) { readLimit=codedInput.PushLimit(messageSize); // Make sure the CodedInputStream doesn't refuse to read the message because it's // read too much already. I'll also add an arbitrary 50 on to always make sure // I can read the next messageSize if there is one. if( gzipInput.ByteCount()+messageSize+50 > totalBytesLimit ) { totalBytesLimit+=messageSize*5; // Might as well set it a little higher than necessary while I'm at it. codedInput.SetTotalBytesLimit( totalBytesLimit, -1 ); } std::unique_ptr<l1menuprotobuf::Run> pNewRun( new l1menuprotobuf::Run ); if( !pNewRun->ParseFromCodedStream( &codedInput ) ) throw std::runtime_error( "ReducedSample initialise from file - some unknown error while reading run" ); protobufRuns.push_back( std::move( pNewRun ) ); codedInput.PopLimit(readLimit); } // Always make sure there is at least one Run ready to be added to. Later // code assumes there is already a run there. if( protobufRuns.empty() ) { std::unique_ptr<l1menuprotobuf::Run> pNewRun( new l1menuprotobuf::Run ); protobufRuns.push_back( std::move( pNewRun ) ); } // Count up the sum of the weights of all events for( const auto& pRun : protobufRuns ) { sumOfWeights+=sumWeights( *pRun ); } // I have all of the information in the protobuf members, but I also need the trigger information // in the form of l1menu::TriggerMenu. Copy out the required information. for( int triggerNumber=0; triggerNumber<protobufSampleHeader.trigger_size(); ++triggerNumber ) { const l1menuprotobuf::Trigger& inputTrigger=protobufSampleHeader.trigger(triggerNumber); mutableTriggerMenu_.addTrigger( inputTrigger.name(), inputTrigger.version() ); // Get a reference to the trigger I just created l1menu::ITrigger& trigger=mutableTriggerMenu_.getTrigger(triggerNumber); // Run through all of the parameters and set them to what they were // when the sample was made. for( int parameterNumber=0; parameterNumber<inputTrigger.parameter_size(); ++parameterNumber ) { const auto& inputParameter=inputTrigger.parameter(parameterNumber); trigger.parameter(inputParameter.name())=inputParameter.value(); } // I should probably check the threshold names exist. I'll do it another time. } }
void EulerianParticleVelocityForce ( cfdemCloud& sm, const fvMesh& mesh, volVectorField& Uf_, volVectorField& Up_, volScalarField& rho_, volScalarField& alpf_, volScalarField& Pg_, volVectorField& MappedDragForce_, const labelListList& particleList_, const bool& weighting_ ) { // Neighbouring cells CPCCellToCellStencil neighbourCells(mesh); // get viscosity field #ifdef comp const volScalarField nufField = sm.turbulence().mu()/rho_; #else const volScalarField& nufField = sm.turbulence().nu(); #endif // Gas pressure gradient volVectorField gradPg_ = fvc::grad(Pg_); interpolationCellPoint<vector> gradPgInterpolator_(gradPg_); // Local variables label cellID(-1); vector drag(0,0,0); vector Ufluid(0,0,0); vector position(0,0,0); scalar voidfraction(1); vector Up(0,0,0); vector Ur(0,0,0); scalar ds(0); scalar nuf(0); scalar rhof(0); vector WenYuDrag(0,0,0); interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_); interpolationCellPoint<vector> UInterpolator_(Uf_); scalar dist_s(0); scalar sumWeights(0); scalarField weightScalar(27,scalar(0.0)); Field <Field <scalar> > particleWeights(particleList_.size(),weightScalar); //Info << " particle size " << particleList_.size() << endl; // Number of particle in a cell scalarField np(mesh.cells().size(),scalar(0)); // Particle volume scalar Volp(0); vector gradPg_int(0,0,0); for(int ii = 0; ii < particleList_.size(); ii++) { int index = particleList_[ii][0]; cellID = sm.cellIDs()[index][0]; position = sm.position(index); Ufluid = UInterpolator_.interpolate(position,cellID); Up = sm.velocity(index); Ur = Ufluid-Up; ds = 2*sm.radius(index); // Calculate WenYu Drag voidfraction = voidfractionInterpolator_.interpolate(position,cellID); nuf = nufField[cellID]; rhof = rho_[cellID]; WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag); Volp = ds*ds*ds*M_PI/6; gradPg_int = gradPgInterpolator_.interpolate(position,cellID); //if (cellID > -1) // particle centre is in domain //{ if(weighting_) { labelList& cellsNeigh = neighbourCells[cellID]; sumWeights = 0; dist_s = 0; //Info << " index = " << index << " ii = " << ii << " cellID = " << cellID << endl; forAll(cellsNeigh,jj) { // Find distances between particle and neighbouring cells dist_s = mag(sm.mesh().C()[cellsNeigh[jj]]-position)/pow(sm.mesh().V()[cellsNeigh[jj]],1./3.); if(dist_s <= 0.5) { particleWeights[ii][jj] = 1./4.*pow(dist_s,4)-5./8.*pow(dist_s,2)+115./192.; } else if (dist_s > 0.5 && dist_s <= 1.5) { particleWeights[ii][jj] = -1./6.*pow(dist_s,4)+5./6.*pow(dist_s,3)-5./4.*pow(dist_s,2)+5./24.*dist_s+55./96.; } else if (dist_s > 1.5 && dist_s <= 2.5) { particleWeights[ii][jj] = pow(2.5-dist_s,4)/24.; } else { particleWeights[ii][jj] = 0; } sumWeights += particleWeights[ii][jj]; } forAll(cellsNeigh,jj) { if ( sumWeights != 0 ) { Up_[cellID] += Up*particleWeights[ii][jj]/sumWeights; MappedDragForce_[cellID] += (WenYuDrag + Volp * gradPg_int) * particleWeights[ii][jj]/sumWeights; } else { Up_[cellID] = vector(0,0,0); MappedDragForce_[cellID] = vector(0,0,0); } } } else {