void xfel::parameter::organizer_base::initialize_gradients_curvatures(){ typedef std::map<std::string,parameter_array>::iterator iter; for (iter M = _P.begin(); M != _P.end(); ++M){ if (M->second.local_flag) {continue;} M->second.gradients = farray(M->second.parameters.size()); M->second.curvatures = farray(M->second.parameters.size()); } }
void templateClassDemo() { unsigned i; /* We will create two arrays using template class "Array". * The first array will be an integer and the second array * will be a floating point array. Please step through the * next two lines to see how this is done. */ Array<int> iarray(10); Array<float> farray(20); /* To see how the template class is initialized, please step through * the following two loops. The first loop will initialize the * array of integers and the second loop will initialize the array * of floating point numbers. */ for (i = 0; i < iarray.getSize(); i++) { iarray[i] = i; } float f = 0.0f; for (i = 0; i < farray.getSize(); i++) { farray[i] = f; f += (float)1.1; } }
double xfel_legacy::algorithm::mark5_iteration::compute_functional_only( farray tox, farray toy, farray spotcx, farray spotcy, farray spotfx, farray spotfy, iarray master_tiles,iarray frames, vec3array partial_r_partial_distance){ model_calcx=farray(spotcx.size(),scitbx::af::init_functor_null<double>()); model_calcy=farray(spotcx.size(),scitbx::af::init_functor_null<double>()); int ntiles = _P["tile_trans"].ndata; SCITBX_ASSERT(tox.size()==ntiles); SCITBX_ASSERT(toy.size()==ntiles); functional = 0.; sine = std::vector<double>(); cosine = std::vector<double>(); farray rotations = _P["tile_rot"].parameters; for (int tidx=0; tidx < ntiles; ++tidx){ cosine.push_back(std::cos(rotations[tidx]*scitbx::constants::pi_180)); sine.push_back(std::sin(rotations[tidx]*scitbx::constants::pi_180)); } const double* translations = &(_P["tile_trans"].parameters.const_ref()[0]); for (int ridx=0; ridx < spotcx.size(); ++ridx){ int itile = master_tiles[ridx]; calc_minus_To_x = spotcx[ridx] - tox[itile]; calc_minus_To_y = spotcy[ridx] - toy[itile]; rotated_o_x = calc_minus_To_x * cosine[itile] - calc_minus_To_y * sine[itile]; rotated_o_y = calc_minus_To_x * sine[itile] + calc_minus_To_y * cosine[itile]; model_calcx[ridx] = rotated_o_x + (tox[itile] + translations[2*itile]); model_calcy[ridx] = rotated_o_y + (toy[itile] + translations[2*itile+1]); double delx = model_calcx[ridx] - spotfx[ridx]; double dely = model_calcy[ridx] - spotfy[ridx]; double delrsq(delx*delx + dely*dely); functional += delrsq; // sum of square differences } return functional; }
void GameData::writeQuestData() { //write json rapidjson::Document document; document.SetArray(); rapidjson::Document::AllocatorType& allocator = document.GetAllocator(); rapidjson::Value str; for (auto& i : m_mapQuestsData) { auto second = i.second; rapidjson::Value object(rapidjson::kObjectType); object.AddMember("id", second->id, allocator); object.AddMember("level", second->level, allocator); str.SetString(second->title.c_str(), second->title.length(), allocator); object.AddMember("title", str, allocator); str.SetString(second->instruct.c_str(), second->instruct.length(), allocator); object.AddMember("instruct", str, allocator); object.AddMember("status", second->status, allocator); str.SetString(second->targetNpc.c_str(), second->targetNpc.length(), allocator); object.AddMember("targetNpc", str, allocator); str.SetString(second->launchNpc.c_str(), second->launchNpc.length(), allocator); object.AddMember("launchNpc", str, allocator); rapidjson::Value farray(rapidjson::kArrayType); for (auto& j : second->forgeID) { rapidjson::Value object(rapidjson::kObjectType); object.SetInt(j); farray.PushBack(object, allocator); } object.AddMember("forgeID", farray, allocator); rapidjson::Value marray(rapidjson::kArrayType); for (auto& j : second->mons_id) { rapidjson::Value object(rapidjson::kObjectType); object.SetInt(j); marray.PushBack(object, allocator); } object.AddMember("mons_id", marray, allocator); object.AddMember("mapID", second->mapID, allocator); object.AddMember("type", second->type, allocator); document.PushBack(object, allocator); } rapidjson::StringBuffer buffer; rapidjson::Writer<rapidjson::StringBuffer> writer(buffer); document.Accept(writer); auto out = buffer.GetString(); ofstream fp(QUESTSAVE_DATA_PATH, ios_base::out); fp << out; }
int main() { int a[3]; a[-1] = farray(a, a[6]); return 0; }
MStatus ProxyViz::compute( const MPlug& plug, MDataBlock& block ) { if(!m_enableCompute) return MS::kSuccess; if( plug == outValue ) { updateWorldSpace(thisMObject() ); MStatus status; ExampVox * defBox = plantExample(0); defBox->setGeomSizeMult(block.inputValue(aradiusMult).asFloat() ); defBox->setGeomBox(block.inputValue(abboxminx).asFloat(), block.inputValue(abboxminy).asFloat(), block.inputValue(abboxminz).asFloat(), block.inputValue(abboxmaxx).asFloat(), block.inputValue(abboxmaxy).asFloat(), block.inputValue(abboxmaxz).asFloat()); float grdsz = defBox->geomExtent() * 32.f ; if(grdsz < 32.f) { AHelper::Info<float>(" ProxyViz input box is too small", grdsz); grdsz = 32.f; AHelper::Info<float>(" trancated to", grdsz); } if(m_toSetGrid) { m_toSetGrid = false; resetGrid(grdsz); } if(_firstLoad) { /// internal cache only, initializing from external cache is obsolete if(!loadInternal(block) ) std::cout<<"\n ERROR proxviz cannot load internal cache"; _firstLoad = 0; } if(!m_toCheckVisibility) { MArrayDataHandle groundMeshArray = block.inputArrayValue(agroundMesh ); MArrayDataHandle groundSpaceArray = block.inputArrayValue(agroundSpace ); /// in case no ground is connected if(updateGround(groundMeshArray, groundSpaceArray )) { moveWithGround(); AHelper::Info<std::string>(" ProxyViz ground ", groundBuildLog() ); } } if(!m_hasParticle) { block.setClean(plug); return MS::kSuccess; } const int ngroups = block.inputValue(agroupcount).asInt(); MDataHandle hdata = block.inputValue(outPositionPP, &status); MFnVectorArrayData farray(hdata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle scaledata = block.inputValue(outScalePP, &status); MFnVectorArrayData scalearray(scaledata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle rotatedata = block.inputValue(outRotationPP, &status); MFnVectorArrayData rotatearray(rotatedata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle replaceData = block.inputValue(outReplacePP, &status); MFnDoubleArrayData replaceArrayFn(replaceData.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system, needs userScalarPP"); block.setClean(plug); return MS::kSuccess; } MVectorArray outPosArray = farray.array(); MVectorArray outScaleArray = scalearray.array(); MVectorArray outRotateArray = rotatearray.array(); MDoubleArray outReplaceArray = replaceArrayFn.array(); if( outPosArray.length() < 1) { block.setClean(plug); return MS::kSuccess; } computePPAttribs(outPosArray, outRotateArray, outScaleArray, outReplaceArray, ngroups); float result = outPosArray.length(); MDataHandle outputHandle = block.outputValue( outValue ); outputHandle.set( result ); block.setClean(plug); } if(plug == outValue1) { MArrayDataHandle hArray = block.inputArrayValue(ainexamp); updateExamples(hArray); float result = 91.f; MDataHandle outputHandle = block.outputValue( outValue1 ); outputHandle.set( result ); block.setClean(plug); } return MS::kSuccess; }
double xfel_legacy::algorithm::mark5_iteration::compute_target( farray tox, farray toy, farray spotcx, farray spotcy, farray spotfx, farray spotfy, iarray master_tiles,iarray frames, vec3array partial_r_partial_distance){ model_calcx=farray(spotcx.size(),scitbx::af::init_functor_null<double>()); model_calcy=farray(spotcx.size(),scitbx::af::init_functor_null<double>()); int ntiles = _P["tile_trans"].ndata; SCITBX_ASSERT(tox.size()==ntiles); SCITBX_ASSERT(toy.size()==ntiles); functional = 0.; sine = std::vector<double>(); cosine = std::vector<double>(); farray rotations = _P["tile_rot"].parameters; for (int tidx=0; tidx < ntiles; ++tidx){ cosine.push_back(std::cos(rotations[tidx]*scitbx::constants::pi_180)); sine.push_back(std::sin(rotations[tidx]*scitbx::constants::pi_180)); } const double* translations = &(_P["tile_trans"].parameters.const_ref()[0]); double* translation_gradients = &(_P["tile_trans"].gradients.ref()[0]); double* rotation_gradients = &(_P["tile_rot"].gradients.ref()[0]); double* frame_trans_gradients = &(_P["frame_trans"].gradients.ref()[0]); double* frame_dist_gradients = &(_P["frame_distance"].gradients.ref()[0]); double* tile_dist_gradients = &(_P["tile_distance"].gradients.ref()[0]); double* frame_rotz_gradients = &(_P["frame_rotz"].gradients.ref()[0]); double* half_mos_gradients = &(_P["half_mosaicity_rad"].gradients.ref()[0]); double* translation_curvatures= &(_P["tile_trans"].curvatures.ref()[0]); double* rotation_curvatures = &(_P["tile_rot"].curvatures.ref()[0]); double* frame_trans_curvatures= &(_P["frame_trans"].curvatures.ref()[0]); double* frame_dist_curvatures = &(_P["frame_distance"].curvatures.ref()[0]); double* tile_dist_curvatures = &(_P["tile_distance"].curvatures.ref()[0]); double* frame_rotz_curvatures = &(_P["frame_rotz"].curvatures.ref()[0]); double* half_mos_curvatures = &(_P["half_mosaicity_rad"].curvatures.ref()[0]); int nframes = _P["frame_trans"].ndata; for (int ridx=0; ridx < spotcx.size(); ++ridx){ int itile = master_tiles[ridx]; int frame_param_no = frames[ridx]; /*printf("ridx %5d frame %5d partmos %8.5f %8.5f %8.5f \n",ridx, frame_param_no, vecc._V["half_mosaicity_rad"].gradients[ridx][0], vecc._V["half_mosaicity_rad"].gradients[ridx][1], vecc._V["half_mosaicity_rad"].gradients[ridx][2] ); */ calc_minus_To_x = spotcx[ridx] - tox[itile]; calc_minus_To_y = spotcy[ridx] - toy[itile]; rotated_o_x = calc_minus_To_x * cosine[itile] - calc_minus_To_y * sine[itile]; rotated_o_y = calc_minus_To_x * sine[itile] + calc_minus_To_y * cosine[itile]; model_calcx[ridx] = rotated_o_x + (tox[itile] + translations[2*itile]); model_calcy[ridx] = rotated_o_y + (toy[itile] + translations[2*itile+1]); partial_partial_theta_x = -calc_minus_To_x * sine[itile] - calc_minus_To_y * cosine[itile]; partial_partial_theta_y = calc_minus_To_x * cosine[itile] - calc_minus_To_y * sine[itile]; partial_sq_theta_x = -calc_minus_To_x * cosine[itile] + calc_minus_To_y * sine[itile]; partial_sq_theta_y = -calc_minus_To_x * sine[itile] - calc_minus_To_y * cosine[itile]; double delx = model_calcx[ridx] - spotfx[ridx]; double dely = model_calcy[ridx] - spotfy[ridx]; double delrsq(delx*delx + dely*dely); functional += delrsq; // sum of square differences vec3 part_r_part_d = partial_r_partial_distance[ridx]; double rotated_part_r_c_x = part_r_part_d[0] * cosine[itile] - part_r_part_d[1] * sine[itile]; double rotated_part_r_c_y = part_r_part_d[0] * sine[itile] + part_r_part_d[1] * cosine[itile]; translation_gradients[2*itile] += 2. * delx; translation_gradients[2*itile+1]+= 2. * dely; if (frame_param_no < nframes){ frame_trans_gradients[2*frame_param_no] += 2. * delx; frame_trans_gradients[2*frame_param_no+1]+= 2. * dely; frame_dist_gradients[frame_param_no] += 2. * ( delx * rotated_part_r_c_y + dely * rotated_part_r_c_x );// SOMETHING IS ROTTEN IN DENMARK } //tile_dist_gradients[itile/2] += 2.*(delx * rotated_part_r_c_y + dely * rotated_part_r_c_x); rotation_gradients[itile] += scitbx::constants::pi_180 * 2.* ( delx * partial_partial_theta_x + dely * partial_partial_theta_y ); translation_curvatures[2*itile] += 2.; translation_curvatures[2*itile+1] += 2.; if (frame_param_no < nframes){ frame_trans_curvatures[2*frame_param_no] += 2.; frame_trans_curvatures[1+2*frame_param_no] += 2.; frame_dist_curvatures[frame_param_no] +=2 * ( rotated_part_r_c_x * rotated_part_r_c_x + rotated_part_r_c_y * rotated_part_r_c_y ); } //tile_dist_curvatures[itile/2] += 2 * ( //rotated_part_r_c_x * rotated_part_r_c_x + rotated_part_r_c_y * rotated_part_r_c_y); rotation_curvatures[itile] += scitbx::constants::pi_180 * scitbx::constants::pi_180 * 2. * ( ( partial_partial_theta_x*partial_partial_theta_x + partial_partial_theta_y*partial_partial_theta_y ) + ( delx*partial_sq_theta_x + dely*partial_sq_theta_y ) ); // XXX make this map lookup more efficient if (_P["frame_rotz"].size()>0 && frame_param_no < nframes){ //rotz angle is in radians; no need for pi_180 prefactor double origin_x = frame_origins[frame_param_no][0]; double origin_y = frame_origins[frame_param_no][1]; // double d_rcth_d_th_x = -(model_calcy[ridx] - origin_y); double d_rcth_d_th_y = model_calcx[ridx] - origin_x; frame_rotz_gradients[frame_param_no] += 2. * ( delx * d_rcth_d_th_x + dely * d_rcth_d_th_y ); frame_rotz_curvatures[frame_param_no] += 2. * ( ( delx * (-d_rcth_d_th_y) + dely * d_rcth_d_th_x) + ( d_rcth_d_th_x * d_rcth_d_th_x + d_rcth_d_th_y * d_rcth_d_th_y) ); } if ( !_P["half_mosaicity_rad"].local_flag && _P["half_mosaicity_rad"].size()>0 && frame_param_no < nframes){ half_mos_gradients[frame_param_no] += 2. * ( delx * vecc._V["half_mosaicity_rad"].gradients[ridx][1] + dely * vecc._V["half_mosaicity_rad"].gradients[ridx][0] ); // SOMETHING IS ROTTEN IN DENMARK (swap x & y for correct derivative) //first order approximation to curvature suggested by David Waterman half_mos_curvatures[frame_param_no] += 2. * ( vecc._V["half_mosaicity_rad"].gradients[ridx].length_sq() // v.v dot product //These two lines are probably wrong. Switch 0 & 1? vecc._V source incorrect? + (delx * vecc._V["half_mosaicity_rad"].curvatures[ridx][1]) + (dely * vecc._V["half_mosaicity_rad"].curvatures[ridx][0]) ); } } return functional; }